@neocompose/cli 0.72.4 → 0.73.1

package/dist/neo.mjs

@@ -872,7 +872,42 @@ function generatedCSharpTypeName(value, fallback) {
   const safe = /^[0-9]/.test(candidate) ? `_${candidate}` : candidate;
   return isGeneratedCSharpReservedKeyword(safe) ? `${safe}Type` : safe;
 }
-var GENERATED_CSHARP_RESERVED_KEYWORDS, GENERATED_CSHARP_IDENTIFIER_REGEX;
+function generatedCSharpShortId(id2) {
+  return id2.replace(/[^A-Za-z0-9_]/g, "").slice(0, 8) || "Id";
+}
+function dialogueGroupReservedNameError(name) {
+  const propertyName = generatedCSharpTypeName(name, "DialogueGroup");
+  if (!DIALOGUE_GROUP_RESERVED_NAMES.has(propertyName)) return void 0;
+  return `Dialogue group name "${name}" is reserved because ${propertyName} is a Dialogues member.`;
+}
+function dialogueGroupPropertyNames(groups, onCollision) {
+  const ordered = [...groups].sort(compareGroupIds);
+  const used = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Map();
+  for (const group of ordered) {
+    const propertyName = generatedCSharpTypeName(group.name, "DialogueGroup");
+    if (!used.has(propertyName)) {
+      used.add(propertyName);
+      names.set(group.id, propertyName);
+      continue;
+    }
+    const uniqueName = `${propertyName}_${generatedCSharpShortId(group.id)}`;
+    onCollision?.({
+      groupId: group.id,
+      groupName: group.name,
+      propertyName,
+      uniqueName
+    });
+    names.set(group.id, uniqueName);
+  }
+  return names;
+}
+function compareGroupIds(left, right) {
+  if (left.id < right.id) return -1;
+  if (left.id > right.id) return 1;
+  return 0;
+}
+var GENERATED_CSHARP_RESERVED_KEYWORDS, GENERATED_CSHARP_IDENTIFIER_REGEX, DIALOGUE_GROUP_RESERVED_NAMES;
 var init_generated_csharp_identifiers = __esm({
   "../packages/neoscript-language/src/generated-csharp-identifiers.ts"() {
     "use strict";
@@ -956,6 +991,240 @@ var init_generated_csharp_identifiers = __esm({
       "while"
     ]);
     GENERATED_CSHARP_IDENTIFIER_REGEX = /^[_A-Za-z][_A-Za-z0-9]*$/;
+    DIALOGUE_GROUP_RESERVED_NAMES = /* @__PURE__ */ new Set([
+      "TryTrigger",
+      "CanTrigger",
+      "VisitCount",
+      "HasVisited",
+      "OnTrigger",
+      "OnEligible",
+      "OnEligibleError"
+    ]);
+  }
+});
+
+// ../packages/neoscript-language/src/dialogue-types.ts
+function renamedDialogueTypeMessage(name, position) {
+  const replacement = RENAMED_DIALOGUE_TYPES.get(name)?.[position];
+  if (replacement === void 0) return void 0;
+  return `\`${name}\` was renamed to \`${replacement}\`.`;
+}
+function method(ownerId, name, returnType, parameters, documentation) {
+  return {
+    id: `${ownerId}:${name}`,
+    name,
+    kind: "method",
+    type: returnType,
+    returnType,
+    parameters,
+    documentation
+  };
+}
+function neoScriptDialogueReferenceMethods(ownerId) {
+  return [
+    method(
+      ownerId,
+      "TryTrigger",
+      BOOL_TYPE,
+      [ON_FINISH_PARAMETER],
+      "Triggers the referenced dialogue. Returns true when it started or was queued."
+    ),
+    method(
+      ownerId,
+      "CanTrigger",
+      BOOL_TYPE,
+      [],
+      "Checks whether the referenced dialogue's conditions are met, without triggering it."
+    )
+  ];
+}
+function rootMethods() {
+  const dialogueId = {
+    name: "dialogueId",
+    type: STRING_TYPE
+  };
+  const pointer = { name: "pointer", type: STRING_TYPE };
+  return [
+    method(
+      NEOSCRIPT_DIALOGUES_TYPE_ID,
+      "TryTrigger",
+      BOOL_TYPE,
+      [dialogueId, ON_FINISH_PARAMETER],
+      "Triggers a direct dialogue. Returns true when it started or was queued."
+    ),
+    method(
+      NEOSCRIPT_DIALOGUES_TYPE_ID,
+      "CanTrigger",
+      BOOL_TYPE,
+      [dialogueId],
+      "Checks whether a direct dialogue's conditions are met, without triggering it."
+    ),
+    method(
+      NEOSCRIPT_DIALOGUES_TYPE_ID,
+      "VisitCount",
+      INT_TYPE,
+      [pointer],
+      "Returns how many times a dialogue or text node was visited."
+    ),
+    method(
+      NEOSCRIPT_DIALOGUES_TYPE_ID,
+      "HasVisited",
+      BOOL_TYPE,
+      [pointer],
+      "Returns whether a dialogue or text node was visited."
+    )
+  ];
+}
+function groupMethods(typeId, receiver) {
+  if (receiver.kind === "standard") {
+    return [
+      method(
+        typeId,
+        "TryTrigger",
+        BOOL_TYPE,
+        [ON_FINISH_PARAMETER],
+        "Triggers this group's highest-priority eligible dialogue. Returns true when it started or was queued."
+      ),
+      method(
+        typeId,
+        "CanTrigger",
+        BOOL_TYPE,
+        [],
+        "Checks whether this group has an eligible dialogue, without triggering it."
+      )
+    ];
+  }
+  if (receiver.kind !== "lookup" || receiver.entryType === void 0) return [];
+  const value = {
+    name: "value",
+    type: receiver.entryType
+  };
+  return [
+    method(
+      typeId,
+      "TryTrigger",
+      BOOL_TYPE,
+      [value, ON_FINISH_PARAMETER],
+      "Triggers the highest-priority eligible dialogue for the lookup value. Returns true when it started or was queued."
+    ),
+    method(
+      typeId,
+      "CanTrigger",
+      BOOL_TYPE,
+      [value],
+      "Checks whether the lookup value has an eligible dialogue, without triggering it."
+    )
+  ];
+}
+function neoScriptDialogueTypes(groups) {
+  const names = dialogueGroupPropertyNames(groups);
+  const children = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const siblings = children.get(group.parentId);
+    if (siblings === void 0) children.set(group.parentId, [group]);
+    else siblings.push(group);
+  }
+  const rootPath = `root.${NEOSCRIPT_DIALOGUES_MEMBER_NAME}`;
+  const types = [];
+  const typeFor = (parentId, path) => {
+    const members = [];
+    for (const group of children.get(parentId) ?? []) {
+      const name = names.get(group.id);
+      const groupPath = `${path}.${name}`;
+      const typeId = `${NEOSCRIPT_DIALOGUES_TYPE_ID}:${group.id}`;
+      const receiver = {
+        kind: group.kind,
+        path: groupPath,
+        groupId: group.id,
+        ...group.lookup ? { entryType: group.lookup.entryType } : {}
+      };
+      const lookup = group.lookup ? ` Looks up ${group.lookup.entryTypeName} in \`${group.lookup.collection}\`.` : "";
+      const documentation = `${KIND_LABELS[group.kind]} \`${groupPath}\`.${lookup}`;
+      types.push({
+        id: typeId,
+        name: groupPath,
+        kind: "synthetic",
+        documentation,
+        dialogues: receiver,
+        members: [
+          ...typeFor(group.id, groupPath),
+          ...groupMethods(typeId, receiver)
+        ]
+      });
+      members.push({
+        id: `${typeId}:member`,
+        name,
+        kind: "property",
+        type: { kind: "named", typeId },
+        documentation,
+        detail: KIND_LABELS[group.kind],
+        writable: false,
+        writability: "readOnly",
+        ...group.location ? { location: group.location } : {},
+        ...group.selectionLocation ? { selectionLocation: group.selectionLocation } : {}
+      });
+    }
+    return members;
+  };
+  const topLevel = typeFor(null, rootPath);
+  types.push({
+    id: NEOSCRIPT_DIALOGUES_TYPE_ID,
+    name: rootPath,
+    kind: "synthetic",
+    documentation: "The project's dialogues and dialogue groups, the same paths as the generated C# Dialogues.",
+    dialogues: { kind: "root", path: rootPath },
+    members: [...topLevel, ...rootMethods()]
+  });
+  return {
+    member: {
+      id: `${NEOSCRIPT_DIALOGUES_TYPE_ID}:member`,
+      name: NEOSCRIPT_DIALOGUES_MEMBER_NAME,
+      kind: "property",
+      type: { kind: "named", typeId: NEOSCRIPT_DIALOGUES_TYPE_ID },
+      documentation: "The project's dialogues. Trigger them, check them, and read dialogue memory.",
+      writable: false,
+      writability: "readOnly"
+    },
+    types
+  };
+}
+var NEOSCRIPT_DIALOGUES_MEMBER_NAME, NEOSCRIPT_DIALOGUES_TYPE_ID, RENAMED_DIALOGUE_TYPES, BOOL_TYPE, INT_TYPE, STRING_TYPE, NEOSCRIPT_DIALOGUE_ON_FINISH_TYPE, ON_FINISH_PARAMETER, KIND_LABELS;
+var init_dialogue_types = __esm({
+  "../packages/neoscript-language/src/dialogue-types.ts"() {
+    "use strict";
+    init_generated_csharp_identifiers();
+    NEOSCRIPT_DIALOGUES_MEMBER_NAME = "Dialogues";
+    NEOSCRIPT_DIALOGUES_TYPE_ID = "builtin:Dialogues";
+    RENAMED_DIALOGUE_TYPES = /* @__PURE__ */ new Map([
+      ["Dialogue", { base: "NeoDialogue", value: "NeoDialogueReference" }],
+      [
+        "DialogueRef",
+        { base: "NeoDialogueReference", value: "NeoDialogueReference" }
+      ],
+      ["DialogueGroup", { base: "NeoDialogueGroup", value: "NeoDialogueGroup" }],
+      ["PriorityGroup", { base: "NeoPriorityGroup", value: "NeoPriorityGroup" }],
+      ["PriorityOption", { base: "NeoPriorityOption", value: "NeoPriorityOption" }]
+    ]);
+    BOOL_TYPE = { kind: "primitive", name: "bool" };
+    INT_TYPE = { kind: "primitive", name: "int" };
+    STRING_TYPE = { kind: "primitive", name: "string" };
+    NEOSCRIPT_DIALOGUE_ON_FINISH_TYPE = {
+      kind: "delegate",
+      returnType: { kind: "primitive", name: "void" },
+      parameterTypes: [],
+      nullable: true
+    };
+    ON_FINISH_PARAMETER = {
+      name: "onFinish",
+      type: NEOSCRIPT_DIALOGUE_ON_FINISH_TYPE,
+      defaultValue: { displayText: "null", value: null },
+      documentation: "Runs once the dialogue ends, whether it finished, failed, or was disposed."
+    };
+    KIND_LABELS = {
+      standard: "Dialogue group",
+      lookup: "Lookup dialogue group",
+      folder: "Dialogue folder"
+    };
   }
 });
 
@@ -1073,10 +1342,11 @@ function vectorTypes() {
     members: structuredLeafFieldProperties(name)
   }));
 }
-var NEO_PROJECT_IGNORED_DIRECTORY_NAMES, NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_ANNOTATION_TYPES, NEOSCRIPT_BUILTIN_NAMESPACES, NEOSCRIPT_BUILTIN_TYPES, NEO_VARIANT_TYPE_NAME, NEO_VARIANT_FOLDER_TYPE_NAME, NEO_LOOKUP_VARIANT_TYPE_NAME, NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME, NEO_VARIANT_SCOPE_NAME, NEO_VARIANT_RESERVED_NAME, NEO_VARIANT_FOLDER_PATH_SEPARATOR, NEOSCRIPT_OPERATORS, STRING_TYPE, INT_TYPE, FLOAT_TYPE, BOOL_TYPE, IMAGE_REF_TYPE, SPRITE_INFO_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_GLOBALS, NEOSCRIPT_SPRITE_INFO_EMPTY_MEMBER_ID, NEOSCRIPT_SPRITE_INFO_EMPTY_VALUE, NEOSCRIPT_MATH_TYPE_ID, MATH_INFERENCE_RULE, MATH_INTEGRAL_RULE, NEOSCRIPT_LIST_TYPE_NAME, NEOSCRIPT_LIST_TYPE_ID, NEOSCRIPT_LIST_REPEAT_NAME, LIST_ENTRY_TYPE, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
+var NEO_PROJECT_IGNORED_DIRECTORY_NAMES, NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_ANNOTATION_TYPES, NEOSCRIPT_BUILTIN_NAMESPACES, NEOSCRIPT_BUILTIN_TYPES, NEO_VARIANT_TYPE_NAME, NEO_VARIANT_FOLDER_TYPE_NAME, NEO_LOOKUP_VARIANT_TYPE_NAME, NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME, NEO_VARIANT_SCOPE_NAME, NEO_VARIANT_RESERVED_NAME, NEO_VARIANT_FOLDER_PATH_SEPARATOR, NEOSCRIPT_OPERATORS, STRING_TYPE2, INT_TYPE2, FLOAT_TYPE, BOOL_TYPE2, IMAGE_REF_TYPE, SPRITE_INFO_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_GLOBALS, NEOSCRIPT_SPRITE_INFO_EMPTY_MEMBER_ID, NEOSCRIPT_SPRITE_INFO_EMPTY_VALUE, NEOSCRIPT_MATH_TYPE_ID, MATH_INFERENCE_RULE, MATH_INTEGRAL_RULE, NEOSCRIPT_LIST_TYPE_NAME, NEOSCRIPT_LIST_TYPE_ID, NEOSCRIPT_LIST_REPEAT_NAME, LIST_ENTRY_TYPE, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
 var init_language_spec = __esm({
   "../packages/neoscript-language/src/language-spec.ts"() {
     "use strict";
+    init_dialogue_types();
     NEO_PROJECT_IGNORED_DIRECTORY_NAMES = /* @__PURE__ */ new Set(
       [
         ".git",
@@ -1147,7 +1417,7 @@ var init_language_spec = __esm({
       "FunctionRef",
       "NeoDelegate",
       "NeoAction",
-      "Dialogue",
+      "NeoDialogue",
       "Trigger",
       "Node",
       "Text",
@@ -1157,7 +1427,7 @@ var init_language_spec = __esm({
       "Outcome",
       "SpriteInfo",
       "AudioClipInfo",
-      "DialogueRef",
+      "NeoDialogueReference",
       "Vector2",
       "Vector2Int",
       "Vector3",
@@ -1206,10 +1476,10 @@ var init_language_spec = __esm({
       "<",
       ">"
     ];
-    STRING_TYPE = { kind: "primitive", name: "string" };
-    INT_TYPE = { kind: "primitive", name: "int" };
+    STRING_TYPE2 = { kind: "primitive", name: "string" };
+    INT_TYPE2 = { kind: "primitive", name: "int" };
     FLOAT_TYPE = { kind: "primitive", name: "float" };
-    BOOL_TYPE = { kind: "primitive", name: "bool" };
+    BOOL_TYPE2 = { kind: "primitive", name: "bool" };
     IMAGE_REF_TYPE = {
       kind: "primitive",
       name: "ImageRef"
@@ -1234,7 +1504,7 @@ var init_language_spec = __esm({
         {
           name: "SliceIndex",
           key: "sliceIndex",
-          type: INT_TYPE,
+          type: INT_TYPE2,
           documentation: "Index into the file's slices."
         }
       ],
@@ -1256,13 +1526,13 @@ var init_language_spec = __esm({
         {
           name: "x",
           key: "x",
-          type: INT_TYPE,
+          type: INT_TYPE2,
           documentation: "Vector2Int x component."
         },
         {
           name: "y",
           key: "y",
-          type: INT_TYPE,
+          type: INT_TYPE2,
           documentation: "Vector2Int y component."
         }
       ],
@@ -1290,19 +1560,19 @@ var init_language_spec = __esm({
         {
           name: "x",
           key: "x",
-          type: INT_TYPE,
+          type: INT_TYPE2,
           documentation: "Vector3Int x component."
         },
         {
           name: "y",
           key: "y",
-          type: INT_TYPE,
+          type: INT_TYPE2,
           documentation: "Vector3Int y component."
         },
         {
           name: "z",
           key: "z",
-          type: INT_TYPE,
+          type: INT_TYPE2,
           documentation: "Vector3Int z component."
         }
       ],
@@ -1349,14 +1619,14 @@ var init_language_spec = __esm({
     NEOSCRIPT_GLOBALS = [
       builtinFunction(
         "VisitCount",
-        INT_TYPE,
-        [parameter("pointer", STRING_TYPE)],
+        INT_TYPE2,
+        [parameter("pointer", STRING_TYPE2)],
         "Returns the number of visits recorded for a dialogue pointer."
       ),
       builtinFunction(
         "HasVisited",
-        BOOL_TYPE,
-        [parameter("pointer", STRING_TYPE)],
+        BOOL_TYPE2,
+        [parameter("pointer", STRING_TYPE2)],
         "Returns whether a dialogue pointer has been visited."
       )
     ];
@@ -1395,8 +1665,8 @@ var init_language_spec = __esm({
           // `FileId` and `SliceIndex` come from the field table above — they are
           // the writable, addressable fields, not derived properties (D11).
           ...structuredLeafFieldProperties("SpriteInfo"),
-          property("SpriteInfo", "FileName", STRING_TYPE, "Asset file name."),
-          property("SpriteInfo", "Name", STRING_TYPE, "Sprite name."),
+          property("SpriteInfo", "FileName", STRING_TYPE2, "Asset file name."),
+          property("SpriteInfo", "Name", STRING_TYPE2, "Sprite name."),
           property(
             "SpriteInfo",
             "Size",
@@ -1426,8 +1696,8 @@ var init_language_spec = __esm({
         name: "AudioClipInfo",
         kind: "builtin",
         members: [
-          property("AudioClipInfo", "FileId", STRING_TYPE, "Asset file id."),
-          property("AudioClipInfo", "Name", STRING_TYPE, "Audio clip name."),
+          property("AudioClipInfo", "FileId", STRING_TYPE2, "Asset file id."),
+          property("AudioClipInfo", "Name", STRING_TYPE2, "Audio clip name."),
           property(
             "AudioClipInfo",
             "DurationSeconds",
@@ -1437,10 +1707,13 @@ var init_language_spec = __esm({
         ]
       },
       {
-        id: "builtin:DialogueRef",
-        name: "DialogueRef",
+        id: "builtin:NeoDialogueReference",
+        name: "NeoDialogueReference",
         kind: "builtin",
-        members: [property("DialogueRef", "id", STRING_TYPE, "Dialogue id.")]
+        members: [
+          property("NeoDialogueReference", "id", STRING_TYPE2, "Dialogue id."),
+          ...neoScriptDialogueReferenceMethods("builtin:NeoDialogueReference")
+        ]
       },
       ...vectorTypes(),
       {
@@ -1462,7 +1735,7 @@ var init_language_spec = __esm({
           returnType: { kind: "primitive", name: "void" },
           static: true,
           parameters: [
-            ...name === "Assert" ? [parameter("condition", BOOL_TYPE)] : [],
+            ...name === "Assert" ? [parameter("condition", BOOL_TYPE2)] : [],
             parameter("message", { kind: "primitive", name: "unknown" })
           ],
           documentation: name === "Assert" ? "Emits an assertion event when condition is false. Both arguments are evaluated. Does not throw." : "Emits a bounded message and the current NeoScript stack. Does not throw when the sink fails."
@@ -1493,25 +1766,25 @@ var init_language_spec = __esm({
             "Round",
             ["x"],
             `Rounds to the nearest integer; midpoints round to even (banker's rounding). ${MATH_INTEGRAL_RULE}`,
-            INT_TYPE
+            INT_TYPE2
           ),
           mathFunction(
             "Floor",
             ["x"],
             `Rounds toward negative infinity. ${MATH_INTEGRAL_RULE}`,
-            INT_TYPE
+            INT_TYPE2
           ),
           mathFunction(
             "Ceiling",
             ["x"],
             `Rounds toward positive infinity. ${MATH_INTEGRAL_RULE}`,
-            INT_TYPE
+            INT_TYPE2
           ),
           mathFunction(
             "Truncate",
             ["x"],
             `Rounds toward zero. ${MATH_INTEGRAL_RULE}`,
-            INT_TYPE
+            INT_TYPE2
           ),
           mathFunction(
             "Abs",
@@ -1522,7 +1795,7 @@ var init_language_spec = __esm({
             "Sign",
             ["x"],
             "Returns -1, 0, or 1 for a negative, zero, or positive value. Accepts int, float, or decimal and always returns int.",
-            INT_TYPE
+            INT_TYPE2
           ),
           mathFunction(
             "Sqrt",
@@ -1563,7 +1836,7 @@ var init_language_spec = __esm({
             returnType: { kind: "list", elementType: LIST_ENTRY_TYPE },
             parameters: [
               parameter("value", LIST_ENTRY_TYPE),
-              parameter("count", INT_TYPE)
+              parameter("count", INT_TYPE2)
             ],
             documentation: "Returns a list of count copies of value. The entry type is inferred from value and the assignment context \u2014 never spell it. value is evaluated exactly once, then count exactly once, so a reference-typed value is the same reference in every entry; count must be a non-negative int, and 0 produces an empty list.",
             static: true
@@ -1675,12 +1948,17 @@ var init_debug_info = __esm({
 });
 
 // ../packages/neoscript-language/src/strict-ir.ts
-var NEOSCRIPT_COMPILER_REVISION;
+var NEOSCRIPT_COMPILER_REVISION, NeoScriptDialogueOp;
 var init_strict_ir = __esm({
   "../packages/neoscript-language/src/strict-ir.ts"() {
     "use strict";
     init_debug_info();
     NEOSCRIPT_COMPILER_REVISION = 17;
+    NeoScriptDialogueOp = /* @__PURE__ */ ((NeoScriptDialogueOp2) => {
+      NeoScriptDialogueOp2["TryTrigger"] = "TryTrigger";
+      NeoScriptDialogueOp2["CanTrigger"] = "CanTrigger";
+      return NeoScriptDialogueOp2;
+    })(NeoScriptDialogueOp || {});
   }
 });
 
@@ -2580,6 +2858,31 @@ function isNSFunctionHasVisited(value) {
   const v = value;
   return v?.type === "hasVisited" /* hasVisited */ && isNSDialogueMemoryFunctionInfo(v.info);
 }
+function isNSDialogueOp(value) {
+  return value === "TryTrigger" || value === "CanTrigger";
+}
+function isOptionalNSPointer(value) {
+  return value === void 0 || isNSPointer(value);
+}
+function isNSFunctionDialogueGroup(value) {
+  const v = value;
+  if (v?.type !== "dialogueGroup" /* dialogueGroup */) return false;
+  const info = v.info;
+  if (typeof info !== "object" || info === null) return false;
+  if (!isNSDialogueOp(Reflect.get(info, "op"))) return false;
+  if (typeof Reflect.get(info, "groupId") !== "string") return false;
+  if (!isOptionalNSPointer(Reflect.get(info, "valuePointer"))) return false;
+  return isOptionalNSPointer(Reflect.get(info, "onFinishPointer"));
+}
+function isNSFunctionDialogue(value) {
+  const v = value;
+  if (v?.type !== "dialogue" /* dialogue */) return false;
+  const info = v.info;
+  if (typeof info !== "object" || info === null) return false;
+  if (!isNSDialogueOp(Reflect.get(info, "op"))) return false;
+  if (!isNSPointer(Reflect.get(info, "dialogueIdPointer"))) return false;
+  return isOptionalNSPointer(Reflect.get(info, "onFinishPointer"));
+}
 function isNSVectorConstructorType(value) {
   return value === 14 /* Vector2 */ || value === 15 /* Vector2Int */ || value === 16 /* Vector3 */ || value === 17 /* Vector3Int */;
 }
@@ -2639,7 +2942,7 @@ function isNSFunction(value) {
   return isNSFunctionClassConstructor(value) || isNSFunctionClassClone(value) || isNSFunctionListIndex(value) || isNSFunctionSelect(value) || isNSFunctionCollectionQuery(value) || isNSFunctionFirst(value) || isNSFunctionFirstOrDefault(value) || isNSFunctionWhere(value) || isNSFunctionContains(value) || isNSFunctionIndexOf(value) || // stringOp was missing from this chain since its introduction — a
   // compiled getter using ToLower()/StartsWith() would fail pointer
   // validation anywhere isNSFunction gates. Fixed alongside decimalOp.
-  isNSFunctionStringOp(value) || isNSFunctionDecimalOp(value) || isNSFunctionMathOp(value) || isNSFunctionListRepeat(value) || isNSFunctionCount(value) || isNSFunctionVisitCount(value) || isNSFunctionHasVisited(value) || isNSFunctionVectorConstructor(value) || isNSFunctionImageSlice(value) || isNSFunctionVariantInitialize(value) || isNSFunctionVariantApply(value) || isNSFunctionDeclaredConstructor(value);
+  isNSFunctionStringOp(value) || isNSFunctionDecimalOp(value) || isNSFunctionMathOp(value) || isNSFunctionListRepeat(value) || isNSFunctionCount(value) || isNSFunctionVisitCount(value) || isNSFunctionHasVisited(value) || isNSFunctionDialogueGroup(value) || isNSFunctionDialogue(value) || isNSFunctionVectorConstructor(value) || isNSFunctionImageSlice(value) || isNSFunctionVariantInitialize(value) || isNSFunctionVariantApply(value) || isNSFunctionDeclaredConstructor(value);
 }
 function isNSInstructionVariable(value) {
   const v = value;
@@ -15178,13 +15481,13 @@ function firstTokenAfter(tokens, offset) {
 function validateDocumentShape(kind, declarations, diagnostics) {
   if (kind === "definition") {
     for (const declaration2 of declarations) {
-      if (declaration2.kind === "class" && declaration2.baseTypes.some((type) => type.name === "Dialogue")) {
+      if (declaration2.kind === "class" && declaration2.baseTypes.some((type) => type.name === "NeoDialogue")) {
         diagnostics.push({
           range: declaration2.nameRange,
           severity: "error",
           source: "neo-project",
           code: "dialogue-class-in-definition",
-          message: "A class that directly derives from `Dialogue` belongs in a `.neoflow` file."
+          message: "A class that directly derives from `NeoDialogue` belongs in a `.neoflow` file."
         });
       }
     }
@@ -15196,7 +15499,7 @@ function validateDocumentShape(kind, declarations, diagnostics) {
       severity: "error",
       source: "neo-project",
       code: "neoflow-single-dialogue-class",
-      message: "A `.neoflow` file must contain exactly one sealed class that directly derives from `Dialogue`."
+      message: "A `.neoflow` file must contain exactly one sealed class that directly derives from `NeoDialogue`."
     });
     return;
   }
@@ -15219,13 +15522,13 @@ function validateDocumentShape(kind, declarations, diagnostics) {
       message: "A `.neoflow` dialogue class cannot be generic."
     });
   }
-  if (declaration.baseTypes.length !== 1 || declaration.baseTypes[0]?.name !== "Dialogue") {
+  if (declaration.baseTypes.length !== 1 || declaration.baseTypes[0]?.name !== "NeoDialogue") {
     diagnostics.push({
       range: declaration.nameRange,
       severity: "error",
       source: "neo-project",
       code: "neoflow-dialogue-base",
-      message: "A `.neoflow` class must directly derive from the system `Dialogue` type."
+      message: "A `.neoflow` class must directly derive from the system `NeoDialogue` type."
     });
   }
   addIncompleteDraftDiagnostic(declaration.annotations, diagnostics);
@@ -16124,7 +16427,7 @@ var init_project_source_parser = __esm({
         this.expect("=");
         const initializerStart = this.cursor;
         const initializer = this.captureInitializer();
-        const dialogueGroup = type.name === "DialogueGroup" ? this.parseDialogueGroupBody(initializerStart, initializer) : void 0;
+        const dialogueGroup = type.name === "NeoDialogueGroup" ? this.parseDialogueGroupBody(initializerStart, initializer) : void 0;
         this.reportNestedTypes(initializer);
         return {
           kind: "global",
@@ -16157,7 +16460,7 @@ var init_project_source_parser = __esm({
           while (!this.done() && !this.at("}") && !this.at("when") && this.cursor < end) {
             const before = this.cursor;
             try {
-              const member = this.parseMember("DialogueGroup", "class");
+              const member = this.parseMember("NeoDialogueGroup", "class");
               if (member?.kind === "function") functions.push(member);
             } catch (error) {
               this.report(error);
@@ -18803,8 +19106,8 @@ var init_project_local_values = __esm({
       "AudioClipRegistry",
       "NeoImage",
       "NeoAudioClip",
-      "PriorityGroup",
-      "DialogueGroup",
+      "NeoPriorityGroup",
+      "NeoDialogueGroup",
       "Migration"
     ]);
   }
@@ -23079,26 +23382,13 @@ function buildDialogueGroupClassNameMap(groups, diagnostics) {
   return names;
 }
 function buildDialogueGroupPropertyNameMap(groups, diagnostics) {
-  const used = /* @__PURE__ */ new Map();
-  const names = /* @__PURE__ */ new Map();
-  for (const group of groups) {
-    const baseName = toCSharpTypeName(group.name, "DialogueGroup");
-    const safeName = isCSharpReservedKeyword(baseName) ? `${baseName}Value` : baseName;
-    const existing = used.get(safeName);
-    if (existing === void 0) {
-      used.set(safeName, group.id);
-      names.set(group.id, safeName);
-      continue;
-    }
-    const uniqueName = `${safeName}_${shortId(group.id)}`;
+  return dialogueGroupPropertyNames(groups, (collision) => {
     diagnostics.push({
       severity: "warning",
-      message: `Generated C# dialogue group property "${safeName}" is duplicated; using "${uniqueName}" for "${group.name}".`,
-      path: `dialogueGroups.${group.id}.name`
+      message: `Generated C# dialogue group property "${collision.propertyName}" is duplicated; using "${collision.uniqueName}" for "${collision.groupName}".`,
+      path: `dialogueGroups.${collision.groupId}.name`
     });
-    names.set(group.id, uniqueName);
-  }
-  return names;
+  });
 }
 function getExtendsClassId(classDef) {
   const value = classDef.extendsClassId;
@@ -25073,7 +25363,7 @@ function resolveLookupEntryMember(ctx, member) {
   return null;
 }
 function shortId(id2) {
-  return id2.replace(/[^A-Za-z0-9_]/g, "").slice(0, 8) || "Id";
+  return generatedCSharpShortId(id2);
 }
 function variantTargetCSharpType(ctx, member, env) {
   const target = member.targetTypeInfo;
@@ -25163,6 +25453,7 @@ var init_unity_member_signatures = __esm({
     "use strict";
     init_neoscript_pattern_bindings();
     init_cell_pattern();
+    init_generated_csharp_identifiers();
     init_members();
     init_world_system_classes();
     init_classes();
@@ -26902,19 +27193,21 @@ function sourceDialogueGroups(source) {
   if (cached) return cached;
   const symbols = /* @__PURE__ */ new Map();
   const globals = /* @__PURE__ */ new Map();
+  const priorityGroups = /* @__PURE__ */ new Map();
   const options = /* @__PURE__ */ new Map();
   for (const symbol of source.symbols) {
     if (symbol.kind !== "global") continue;
-    if (symbol.detail !== "DialogueGroup" && symbol.detail !== "PriorityGroup")
+    if (symbol.detail !== "NeoDialogueGroup" && symbol.detail !== "NeoPriorityGroup")
       continue;
     const id2 = symbol.id ?? `${symbol.location.uri}#${symbol.name}`;
     globals.set(symbol.name, id2);
+    if (symbol.detail === "NeoPriorityGroup")
+      priorityGroups.set(symbol.name, id2);
     symbols.set(id2, symbol);
   }
   for (const symbol of source.symbols) {
-    if (symbol.kind !== "graphChild" || symbol.detail !== "PriorityOption")
-      continue;
-    const owner = globals.get(symbol.ownerName ?? "");
+    if (symbol.kind !== "graphChild") continue;
+    const owner = priorityGroups.get(symbol.ownerName ?? "");
     if (!owner) continue;
     const id2 = symbol.id ?? `${owner}.${symbol.name}`;
     symbols.set(id2, symbol);
@@ -26928,7 +27221,7 @@ function sourceDialogueGroups(source) {
     for (const declaration of document.declarations) {
       if (declaration.kind !== "global") continue;
       const type = declaration.type.name;
-      if (type !== "DialogueGroup" && type !== "Project") continue;
+      if (type !== "NeoDialogueGroup" && type !== "Project") continue;
       const args = constructorArgs(
         declaration.dialogueGroup?.constructor.text ?? declaration.initializer.text
       );
@@ -27009,12 +27302,30 @@ function validateDialogueGroupPaths(source) {
   }
   return diagnostics;
 }
+function validateDialogueGroupNames(source) {
+  const diagnostics = [];
+  const catalog = sourceDialogueGroups(source);
+  for (const group of catalog.paths.byId.values()) {
+    const message = dialogueGroupReservedNameError(group.name);
+    const symbol = catalog.symbols.get(group.id);
+    if (message === void 0 || symbol === void 0) continue;
+    diagnostics.push({
+      uri: symbol.location.uri,
+      severity: "error",
+      code: "reserved-dialogue-group-name",
+      message,
+      range: symbol.location.range
+    });
+  }
+  return diagnostics;
+}
 var catalogs;
 var init_project_source_dialogue_groups = __esm({
   "../packages/neoscript-language/src/project-source-dialogue-groups.ts"() {
     "use strict";
     init_dialogue_group_paths();
     init_executable_parser();
+    init_generated_csharp_identifiers();
     catalogs = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -27237,6 +27548,7 @@ function collectGlobalChildEntries(syntax, declaration) {
       const value = tokens[index + 3];
       entries.push({
         typeName: token.text,
+        typeRange: token.range,
         name: name.text,
         nameRange: name.range,
         annotations: pendingAnnotations,
@@ -29640,6 +29952,43 @@ function enumLiteralKeyOptionId(pointer) {
   }
   return pointer.value.value[0];
 }
+function isDialogueRequestName(name) {
+  return name === "TryTrigger" || name === "CanTrigger";
+}
+function dialogueBodyKindLabel(kind) {
+  if (kind === "initializer" || kind === "initializerExpression")
+    return "an initializer";
+  return `a ${kind}`;
+}
+function capitalize(text) {
+  return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+function requireDialogueArgCount(name, args, required2, acceptsOnFinish, pos) {
+  if (!acceptsOnFinish) {
+    requireArgCount(name, args, required2, pos);
+    return;
+  }
+  if (args.length === required2 || args.length === required2 + 1) return;
+  throw new CompileError(
+    `${name} expects ${required2} or ${required2 + 1} arguments, got ${args.length}.`,
+    pos
+  );
+}
+function dialogueValueError(receiver) {
+  if (receiver.kind === "root") {
+    return `\`${receiver.path}\` is not a value. Use one of its members.`;
+  }
+  if (receiver.kind === "folder") {
+    return `\`${receiver.path}\` is a dialogue folder, not a value. Use one of its groups' members.`;
+  }
+  return `\`${receiver.path}\` is a dialogue group, not a value. Use one of its members.`;
+}
+function dialogueIntrinsic(fn) {
+  return {
+    pointer: { type: "function" /* Function */, function: fn },
+    type: { kind: "primitive", name: "bool" }
+  };
+}
 function intrinsic(kind, info, type) {
   return {
     pointer: {
@@ -29846,7 +30195,7 @@ function primitiveValueKind(name) {
       return 11 /* Sprite */;
     case "AudioClipInfo":
       return 12 /* Audio */;
-    case "DialogueRef":
+    case "NeoDialogueReference":
       return 18 /* DialogueLookup */;
     case "Vector2":
       return 14 /* Vector2 */;
@@ -29879,7 +30228,7 @@ function valueKindPrimitive(kind) {
     case 12 /* Audio */:
       return "AudioClipInfo";
     case 18 /* DialogueLookup */:
-      return "DialogueRef";
+      return "NeoDialogueReference";
     case 14 /* Vector2 */:
       return "Vector2";
     case 15 /* Vector2Int */:
@@ -30059,7 +30408,7 @@ function resolvePrimitiveMember(type, name) {
     if (name === "length")
       return { type: { kind: "primitive", name: "float" } };
   }
-  if (type.name === "DialogueRef" && name === "id")
+  if (type.name === "NeoDialogueReference" && name === "id")
     return { type: { kind: "primitive", name: "string" } };
   return null;
 }
@@ -30158,7 +30507,7 @@ function namedPrimitive(name) {
     case "decimal":
     case "SpriteInfo":
     case "AudioClipInfo":
-    case "DialogueRef":
+    case "NeoDialogueReference":
     case "Vector2":
     case "Vector2Int":
     case "Vector3":
@@ -30393,7 +30742,10 @@ function resolveNeoScriptType(type, context, project) {
       }
       const named = project.typeByName.get(type.name);
       if (!named)
-        throw new CompileError(`Unknown type '${type.name}'`, type.pos);
+        throw new CompileError(
+          renamedDialogueTypeMessage(type.name, "value") ?? `Unknown type '${type.name}'`,
+          type.pos
+        );
       resolved = {
         kind: "named",
         typeId: named.id,
@@ -30459,6 +30811,7 @@ var init_strict_resolver = __esm({
     init_strict_compile_error();
     init_strict_ir();
     init_test_prelude();
+    init_dialogue_types();
     init_tile_conversion();
     CONSTRUCTING_FUNCTION_KINDS = /* @__PURE__ */ new Set(
       [
@@ -31883,23 +32236,23 @@ var init_strict_resolver = __esm({
       resolveDebugStatement(expr, scope) {
         if (expr.kind !== "call" || expr.callee.kind !== "member" || expr.callee.receiver.kind !== "ident" || expr.callee.receiver.name !== "Debug" || this.hasValueReceiver("Debug", scope) || this.project.typeByName.get("Debug")?.id !== "builtin:Debug" && this.project.typeByName.has("Debug"))
           return null;
-        const method2 = expr.callee.name;
+        const method3 = expr.callee.name;
         const severities = {
           Log: "log",
           LogWarning: "warning",
           LogError: "error",
           Assert: "assert"
         };
-        if (!Object.hasOwn(severities, method2))
-          throw new CompileError(`Unknown Debug method '${method2}'.`, expr.pos);
-        const severity = severities[method2];
-        const expected = method2 === "Assert" ? 2 : 1;
+        if (!Object.hasOwn(severities, method3))
+          throw new CompileError(`Unknown Debug method '${method3}'.`, expr.pos);
+        const severity = severities[method3];
+        const expected = method3 === "Assert" ? 2 : 1;
         if (expr.args.length !== expected)
           throw new CompileError(
-            `Debug.${method2} expects ${expected} argument(s).`,
+            `Debug.${method3} expects ${expected} argument(s).`,
             expr.pos
           );
-        const condition = method2 === "Assert" ? this.resolveExpression(requiredAt(expr.args, 0), scope) : void 0;
+        const condition = method3 === "Assert" ? this.resolveExpression(requiredAt(expr.args, 0), scope) : void 0;
         if (condition && (!isPrimitive(condition.type, "bool") || isNullable(condition.type)))
           throw new CompileError(
             "Debug.Assert requires a non-null bool condition.",
@@ -32789,6 +33142,17 @@ var init_strict_resolver = __esm({
         }
       }
       resolveExpression(expression, scope, expected) {
+        const result = this.resolveReceiverExpression(expression, scope, expected);
+        if (result.dialogues !== void 0) {
+          throw new CompileError(
+            dialogueValueError(result.dialogues),
+            expression.pos
+          );
+        }
+        return result;
+      }
+      /** {@link resolveExpression} that also admits a `root.Dialogues` receiver. */
+      resolveReceiverExpression(expression, scope, expected) {
         let result = this.resolveExpressionCore(expression, scope, expected);
         if (result.pointer.type === "function" /* Function */ || result.pointer.type === "callFunction" /* CallFunction */ || result.pointer.type === "callDelegate" /* CallDelegate */ || result.pointer.type === "callAction" /* CallAction */ || result.pointer.type === "callGetter" /* CallGetter */) {
           result = {
@@ -34366,7 +34730,7 @@ var init_strict_resolver = __esm({
             return this.resolveStaticMemberValue(staticType, member, pos);
           }
         }
-        const resolvedReceiver = receiverValue ? receiverValue() : this.resolveExpression(receiverAst, scope);
+        const resolvedReceiver = receiverValue ? receiverValue() : this.resolveReceiverExpression(receiverAst, scope);
         if (optional2 && !isNullable(resolvedReceiver.type)) {
           throw new CompileError(
             `\`?.\` requires an optional receiver; got ${this.describe(resolvedReceiver.type)}`,
@@ -34462,7 +34826,7 @@ var init_strict_resolver = __esm({
         }
         const primitiveMember = resolvePrimitiveMember(receiver.type, name);
         if (primitiveMember) {
-          if (isPrimitive(receiver.type, "DialogueRef")) {
+          if (isPrimitive(receiver.type, "NeoDialogueReference")) {
             return {
               pointer: {
                 type: "keyOf" /* KeyOf */,
@@ -34495,12 +34859,15 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        if (isPrimitive(receiver.type, "DialogueRef")) {
+        if (isPrimitive(receiver.type, "NeoDialogueReference")) {
           throw new CompileError(
             `${this.describe(receiver.type)} has no member '${name}'`,
             pos
           );
         }
+        if (receiver.dialogues !== void 0) {
+          return this.resolveDialogueGroupRead(receiver, name, pos);
+        }
         const memberReceiverType = neoScriptMemberLookupType(receiver.type);
         if (memberReceiverType.kind === "named") {
           const type = this.project.typeById.get(memberReceiverType.typeId);
@@ -34529,6 +34896,10 @@ var init_strict_resolver = __esm({
           if (this.userClassCode && type.id === this.rootTypeId && member.writability !== "user") {
             throw new CompileError("User code can only read `root.User`.", pos);
           }
+          const dialogues = this.dialogueReceiverOf(member.type);
+          if (dialogues !== void 0) {
+            return { ...literal(member.type, null), dialogues, symbol: member };
+          }
           if (member.static === true) {
             throw new CompileError(
               `Static member '${type.name}.${name}' must be accessed through the type name, not an instance.`,
@@ -34883,6 +35254,227 @@ var init_strict_resolver = __esm({
           );
         }
       }
+      /** P105 §2.1. The receiver a value of this type is, if it is one. */
+      dialogueReceiverOf(type) {
+        if (type.kind !== "named") return void 0;
+        return this.project.typeById.get(type.typeId)?.dialogues;
+      }
+      /** P105 §2.1. `<receiver>.<Group>`; the methods are only callable. */
+      resolveDialogueGroupRead(receiver, name, pos) {
+        const path = receiver.dialogues.path;
+        const type = receiver.type.kind === "named" ? this.project.typeById.get(receiver.type.typeId) : void 0;
+        const member = type?.members.find((candidate) => candidate.name === name);
+        if (member === void 0) {
+          throw new CompileError(`${path} has no dialogue group '${name}'.`, pos);
+        }
+        if (member.kind === "method") {
+          throw new CompileError(
+            `'${path}.${name}' must be called with \`()\`; it cannot be read as a value.`,
+            pos
+          );
+        }
+        const dialogues = this.dialogueReceiverOf(member.type);
+        if (dialogues === void 0) {
+          throw new Error(
+            `Dialogue group member '${path}.${name}' has no group type.`
+          );
+        }
+        return { ...literal(member.type, null), dialogues, symbol: member };
+      }
+      /** P105 §2.1. A call on `root.Dialogues` or one of its groups. */
+      resolveDialogueReceiverCall(receiver, name, args, scope, pos) {
+        if (receiver.kind === "root") {
+          if (name === "VisitCount" || name === "HasVisited") {
+            return this.resolveDialogueMemoryRead(name, args, scope, pos);
+          }
+          if (!isDialogueRequestName(name)) {
+            throw new CompileError(
+              `${receiver.path} has no method '${name}'.`,
+              pos
+            );
+          }
+          this.assertDialogueRequestAllowed(name, pos);
+          requireDialogueArgCount(name, args, 1, name === "TryTrigger", pos);
+          const dialogueId = this.resolveExpression(requiredAt(args, 0), scope, {
+            kind: "primitive",
+            name: "string"
+          });
+          this.requireAssignable(
+            dialogueId.type,
+            { kind: "primitive", name: "string" },
+            requiredAt(args, 0).pos,
+            "dialogueId"
+          );
+          return dialogueIntrinsic({
+            type: "dialogue" /* Dialogue */,
+            info: {
+              op: NeoScriptDialogueOp[name],
+              dialogueIdPointer: dialogueId.pointer,
+              ...this.dialogueOnFinish(args[1], scope)
+            }
+          });
+        }
+        if (!isDialogueRequestName(name)) {
+          throw new CompileError(`${receiver.path} has no member '${name}'.`, pos);
+        }
+        if (receiver.kind === "folder") {
+          throw new CompileError(
+            `${receiver.path} is a dialogue folder, so it has no '${name}'. Use one of its groups' members.`,
+            pos
+          );
+        }
+        this.assertDialogueRequestAllowed(name, pos);
+        if (receiver.kind === "standard") {
+          requireDialogueArgCount(name, args, 0, name === "TryTrigger", pos);
+          return dialogueIntrinsic({
+            type: "dialogueGroup" /* DialogueGroup */,
+            info: {
+              op: NeoScriptDialogueOp[name],
+              groupId: receiver.groupId,
+              ...this.dialogueOnFinish(args[0], scope)
+            }
+          });
+        }
+        const entryType = receiver.entryType;
+        if (entryType === void 0) {
+          throw new CompileError(
+            `${receiver.path} can't be triggered: its lookup collection has no entry class.`,
+            pos
+          );
+        }
+        requireDialogueArgCount(name, args, 1, name === "TryTrigger", pos);
+        const value = this.resolveExpression(requiredAt(args, 0), scope, entryType);
+        this.requireAssignable(
+          value.type,
+          entryType,
+          requiredAt(args, 0).pos,
+          "lookup value"
+        );
+        return dialogueIntrinsic({
+          type: "dialogueGroup" /* DialogueGroup */,
+          info: {
+            op: NeoScriptDialogueOp[name],
+            groupId: receiver.groupId,
+            valuePointer: value.pointer,
+            ...this.dialogueOnFinish(args[1], scope)
+          }
+        });
+      }
+      /**
+       * P105 §2.2. `NeoDialogueReference` methods request the dialogue by the
+       * reference's `id`, the same index-0 read `.id` lowers to.
+       */
+      resolveDialogueReferenceCall(receiver, name, args, scope, pos, optional2) {
+        if (this.userClassCode) {
+          throw new CompileError(
+            `User code can't use ${name}. Dialogues run against a save.`,
+            pos
+          );
+        }
+        const nullPropagating = optional2 || receiver.optionalChainType !== void 0;
+        if (!optional2 && isNullable(receiver.type)) {
+          throw new CompileError(
+            `Member '${name}' is called on ${this.describe(receiver.type)}, which may be null. Handle null before calling through it \u2014 use \`!\` if it is always set, or \`?.\` or a null check that narrows it.`,
+            pos
+          );
+        }
+        this.assertDialogueRequestAllowed(name, pos);
+        requireDialogueArgCount(name, args, 0, name === "TryTrigger", pos);
+        const resolved = dialogueIntrinsic({
+          type: "dialogue" /* Dialogue */,
+          info: {
+            op: NeoScriptDialogueOp[name],
+            dialogueIdPointer: {
+              type: "keyOf" /* KeyOf */,
+              keyOf: { pointer: receiver.pointer, key: numberPointer(0) },
+              ...nullPropagating ? { optional: true } : {}
+            },
+            ...this.dialogueOnFinish(args[0], scope)
+          }
+        });
+        if (!nullPropagating) return resolved;
+        return {
+          ...resolved,
+          type: { ...resolved.type, nullable: true },
+          optionalChainType: resolved.type
+        };
+      }
+      dialogueOnFinish(argument2, scope) {
+        if (argument2 === void 0) return {};
+        const onFinish = this.resolveExpression(
+          argument2,
+          scope,
+          NEOSCRIPT_DIALOGUE_ON_FINISH_TYPE
+        );
+        this.requireAssignable(
+          onFinish.type,
+          NEOSCRIPT_DIALOGUE_ON_FINISH_TYPE,
+          argument2.pos,
+          "onFinish"
+        );
+        return { onFinishPointer: onFinish.pointer };
+      }
+      /**
+       * P105 §2.4. Requests run only from bodies that run once per call; reads
+       * run wherever dialogue memory has a value.
+       */
+      assertDialogueRequestAllowed(name, pos) {
+        if (name === "CanTrigger") {
+          this.assertDialogueMemoryReadable(name, pos);
+          return;
+        }
+        const kind = this.context.kind;
+        if (kind === "function" || kind === "action") return;
+        if (kind === "getter" || kind === "property" || kind === "condition") {
+          throw new CompileError(
+            "A getter can't trigger a dialogue. It runs whenever its value is read.",
+            pos
+          );
+        }
+        if (kind === "setter") {
+          throw new CompileError(
+            "A setter can't trigger a dialogue. Trigger it from a function.",
+            pos
+          );
+        }
+        throw new CompileError(
+          `${capitalize(dialogueBodyKindLabel(kind))} body can't trigger a dialogue. Dialogues only run during play.`,
+          pos
+        );
+      }
+      /**
+       * P43 §7.2.2. Dialogue memory is runtime state; it has no value at push
+       * time, in a freshly constructed instance, or while migrating a save.
+       */
+      assertDialogueMemoryReadable(name, pos) {
+        const kind = this.context.kind;
+        if (!isNeoScriptConstructionDocumentKind(kind) && kind !== "migration") {
+          return;
+        }
+        throw new CompileError(
+          `${name} reads runtime dialogue memory, which has no meaning in ${dialogueBodyKindLabel(kind)} body.`,
+          pos
+        );
+      }
+      resolveDialogueMemoryRead(name, args, scope, pos) {
+        this.assertDialogueMemoryReadable(name, pos);
+        requireArgCount(name, args, 1, pos);
+        const pointer = this.resolveExpression(requiredAt(args, 0), scope, {
+          kind: "primitive",
+          name: "string"
+        });
+        if (!isPrimitive(pointer.type, "string")) {
+          throw new CompileError(
+            `${name} pointer must be a string; got ${this.describe(pointer.type)}`,
+            pos
+          );
+        }
+        return intrinsic(
+          name === "VisitCount" ? "visitCount" /* VisitCount */ : "hasVisited" /* HasVisited */,
+          { pointer: pointer.pointer },
+          { kind: "primitive", name: name === "VisitCount" ? "int" : "bool" }
+        );
+      }
       /**
        * P69 §2.7. A member read on the `Math` namespace: the two constants lower
        * to `float` literals, and nothing else on `Math` is readable as a value.
@@ -35088,7 +35680,9 @@ var init_strict_resolver = __esm({
         return () => {
           if (!result) {
             try {
-              result = { value: this.resolveExpression(callee.receiver, scope) };
+              result = {
+                value: this.resolveReceiverExpression(callee.receiver, scope)
+              };
             } catch (error) {
               result = { error };
             }
@@ -35143,31 +35737,11 @@ var init_strict_resolver = __esm({
           if (vector3)
             return this.resolveVectorConstructor(vector3, argumentsList2, scope, pos);
           if (callee.name === "VisitCount" || callee.name === "HasVisited") {
-            if (isNeoScriptConstructionDocumentKind(this.context.kind)) {
-              throw new CompileError(
-                `${callee.name} reads runtime dialogue memory, which has no meaning in a ${this.context.kind} body.`,
-                pos
-              );
-            }
-            requireArgCount(callee.name, argumentsList2, 1, pos);
-            const pointer = this.resolveExpression(
-              requiredAt(argumentsList2, 0),
+            return this.resolveDialogueMemoryRead(
+              callee.name,
+              argumentsList2,
               scope,
-              { kind: "primitive", name: "string" }
-            );
-            if (!isPrimitive(pointer.type, "string")) {
-              throw new CompileError(
-                `${callee.name} pointer must be a string; got ${this.describe(pointer.type)}`,
-                pos
-              );
-            }
-            return intrinsic(
-              callee.name === "VisitCount" ? "visitCount" /* VisitCount */ : "hasVisited" /* HasVisited */,
-              { pointer: pointer.pointer },
-              {
-                kind: "primitive",
-                name: callee.name === "VisitCount" ? "int" : "bool"
-              }
+              pos
             );
           }
           const global = this.context.project.globals.find(
@@ -35272,12 +35846,37 @@ var init_strict_resolver = __esm({
         }
         const receiver = receiverValue();
         const optional2 = callee.optional === true;
+        if (receiver.dialogues !== void 0) {
+          if (optional2) {
+            throw new CompileError(
+              `\`?.\` is not valid on ${receiver.dialogues.path}; it is never null.`,
+              pos
+            );
+          }
+          return this.resolveDialogueReceiverCall(
+            receiver.dialogues,
+            callee.name,
+            argumentsList2,
+            scope,
+            pos
+          );
+        }
         if (optional2 && !isNullable(receiver.type)) {
           throw new CompileError(
             `\`?.\` requires an optional receiver; got ${this.describe(receiver.type)}`,
             pos
           );
         }
+        if (isPrimitive(receiver.type, "NeoDialogueReference") && isDialogueRequestName(callee.name)) {
+          return this.resolveDialogueReferenceCall(
+            receiver,
+            callee.name,
+            argumentsList2,
+            scope,
+            pos,
+            optional2
+          );
+        }
         if (callee.name === "Slice" && isPrimitive(receiver.type, "ImageRef")) {
           return this.resolveImageSlice(receiver, argumentsList2, scope, pos);
         }
@@ -37559,6 +38158,7 @@ var init_strict_resolver = __esm({
           }
         }
         const receiver = receiverValue();
+        if (receiver.dialogues !== void 0) return null;
         const memberReceiverType = neoScriptMemberLookupType(receiver.type);
         if (memberReceiverType.kind !== "named") return null;
         const type = this.project.typeById.get(memberReceiverType.typeId);
@@ -42586,7 +43186,7 @@ function createEnvironment(documents, project) {
       if (declaration.kind === "class") {
         types.set(declaration.name, declaration);
         const dialogue = declaration.baseTypes.some(
-          (base) => base.name === "Dialogue"
+          (base) => base.name === "NeoDialogue"
         );
         if (dialogue) {
           referenceTargets.set(declaration.name, {
@@ -43303,7 +43903,9 @@ function fieldsForAnnotation(name, context, environment) {
   }
   if (name === "primary") return context.kind === "flowBinding" ? [] : null;
   if (name === "incomplete") {
-    return context.kind === "flowGraph" || context.kind === "flowMember" || context.kind === "class" && context.declaration.baseTypes.some((type) => type.name === "Dialogue") ? [{ name: "reason", type: "string" }] : null;
+    return context.kind === "flowGraph" || context.kind === "flowMember" || context.kind === "class" && context.declaration.baseTypes.some(
+      (type) => type.name === "NeoDialogue"
+    ) ? [{ name: "reason", type: "string" }] : null;
   }
   if (name === "visibility") {
     return context.kind === "class" ? [{ name: "visibility", type: "NeoClassVisibility" }] : null;
@@ -43347,7 +43949,7 @@ function settingsFields(context) {
     ];
   }
   if (context.kind === "class") {
-    if (context.declaration.baseTypes.some((type2) => type2.name === "Dialogue")) {
+    if (context.declaration.baseTypes.some((type2) => type2.name === "NeoDialogue")) {
       return [
         { name: "name", type: "string" },
         { name: "description", type: "string" },
@@ -43382,7 +43984,7 @@ function settingsFields(context) {
     );
   }
   if (type.name === "Lookup") return lookupSettingsFields();
-  if (type.name === "Dialogue")
+  if (type.name === "NeoDialogueReference")
     return settingsClassFields("NeoDialogueSettings");
   if (type.name === "NeoImage" || type.name === "NeoAudioClip" || type.name === "SpriteInfo" || type.name === "AudioClipInfo") {
     return settingsClassFields("NeoFileSettings").filter(
@@ -44815,7 +45417,8 @@ function subscriptKeyType(receiver) {
   if (receiver?.name === "List") return primitiveType("int");
   return void 0;
 }
-function validateReferenceExpression(expression, expected, environment, uri, range2, diagnostics) {
+function validateReferenceExpression(expression, declared, environment, uri, range2, diagnostics) {
+  const expected = declared?.name === "NeoDialogueReference" ? { ...declared, name: "NeoDialogue" } : declared;
   const typeArguments = expression.typeArguments ?? [];
   const names = expression.argumentNames ?? [];
   const idIndex = names.findIndex((name) => name === "id");
@@ -44907,7 +45510,7 @@ function validateReferenceExpression(expression, expected, environment, uri, ran
     );
     return;
   }
-  if (target.kind === "dialogue" && expected && expected.name !== "Dialogue") {
+  if (target.kind === "dialogue" && expected && expected.name !== "NeoDialogue") {
     if (!referenceTypeAssignable(target.type, expected, environment)) {
       malformed(
         `Dialogue target ${path} is incompatible with expected target ${describeType(expected)}.`
@@ -44941,8 +45544,8 @@ function referenceTargetPath(expression) {
   return receiver === null ? null : `${receiver}.${expression.name}`;
 }
 function isDialogueReferenceType(type, environment) {
-  if (type.name === "Dialogue") return true;
-  return classExtends(type.name, "Dialogue", environment, /* @__PURE__ */ new Set());
+  if (type.name === "NeoDialogue") return true;
+  return classExtends(type.name, "NeoDialogue", environment, /* @__PURE__ */ new Set());
 }
 function referenceTypeAssignable(actual, expected, environment) {
   if (actual.name === expected.name) {
@@ -45876,14 +46479,18 @@ function successfulBodyCache(project) {
 }
 function compileProjectSourceBodies(documents) {
   const graph = buildProjectGraph(documents);
-  const groupContexts = dialogueGroupContexts(documents, graph);
-  const project = {
-    ...graph.project,
-    types: [
-      ...graph.project.types,
-      ...[...groupContexts.values()].map((group) => group.contextType)
-    ]
-  };
+  const groups = sourceDialogueGroups2(documents, graph);
+  const groupContexts = groups.contexts;
+  const dialogues = neoScriptDialogueTypes(groups.sources);
+  const types = [];
+  for (const type of graph.project.types) {
+    types.push(
+      type.id === PROJECT_ROOT_TYPE_ID ? { ...type, members: [...type.members, dialogues.member] } : type
+    );
+  }
+  for (const group of groupContexts.values()) types.push(group.contextType);
+  types.push(...dialogues.types);
+  const project = { ...graph.project, types };
   const projectIndex = createProjectIndex(project);
   const bodyCache = successfulBodyCache(project);
   const bodies = [];
@@ -46100,76 +46707,78 @@ function compileProjectSourceBodies(documents) {
   }
   return { project, bodies, contexts, diagnostics };
 }
-function dialogueGroupContexts(documents, graph) {
-  const result = /* @__PURE__ */ new Map();
-  let index;
-  let membersByType;
-  const collectionMembersByType = () => membersByType ??= new Map(
-    graph.project.types.map((type) => [
-      type.name,
-      new Map(type.members.map((member) => [member.name, member]))
-    ])
-  );
+function sourceDialogueGroups2(documents, graph) {
+  const declarations = [];
+  const idsByName = /* @__PURE__ */ new Map();
   for (const [uri, document] of documents) {
     for (const declaration of document.declarations) {
-      if (declaration.kind !== "global" || !declaration.dialogueGroup) continue;
-      let thisType;
-      try {
-        const constructor2 = parseExpression(
-          declaration.dialogueGroup.constructor.text
-        );
-        if (constructor2.kind === "new") {
-          const kind = constructor2.args[constructor2.argumentNames?.indexOf("kind") ?? -1];
-          const collection = constructor2.args[constructor2.argumentNames?.indexOf("collection") ?? -1];
-          if (kind?.kind === "contextualEnum" && kind.name === "Lookup") {
-            let member;
-            if (collection?.kind === "member" && collection.receiver.kind === "ident") {
-              member = collectionMembersByType().get(collection.receiver.name)?.get(collection.name);
-            } else if (collection?.kind === "call" && collection.callee.kind === "ident" && collection.callee.name === "Reference") {
-              const id3 = collection.args[collection.argumentNames?.indexOf("id") ?? -1];
-              if (id3?.kind === "litString")
-                member = (index ??= createProjectIndex(
-                  graph.project
-                )).symbolById.get(id3.value);
-            }
-            let entry;
-            if (member?.type.kind === "list") entry = member.type.elementType;
-            if (member?.type.kind === "dictionary")
-              entry = member.type.valueType;
-            if (entry?.kind === "named")
-              thisType = { ...entry, nullable: false };
-          }
-        }
-      } catch {
-      }
-      const id2 = `dialogue-context:${uri}:${declaration.name}`;
-      result.set(declaration, {
-        ...thisType ? { thisType } : {},
-        contextType: {
-          id: id2,
-          name: "DialogueContext",
-          kind: "synthetic",
-          members: [
-            {
-              id: `${id2}:primary`,
-              name: "primary",
-              kind: "property",
-              type: { kind: "primitive", name: "unknown" },
-              writable: false
-            },
-            {
-              id: `${id2}:trigger`,
-              name: "trigger",
-              kind: "property",
-              type: thisType ?? { kind: "primitive", name: "null" },
-              writable: false
-            }
-          ]
-        }
-      });
+      if (declaration.kind !== "global") continue;
+      if (declaration.type.name !== "NeoDialogueGroup") continue;
+      const id2 = sourceIdentity2(
+        declaration.annotations,
+        `dialogue-group:${uri}:${declaration.name}`
+      );
+      idsByName.set(declaration.name, id2);
+      declarations.push({ uri, declaration, id: id2 });
     }
   }
-  return result;
+  const lookups = new SourceDialogueGroupLookups(graph);
+  const contexts = /* @__PURE__ */ new Map();
+  const sources2 = [];
+  for (const { uri, declaration, id: id2 } of declarations) {
+    const args = constructorArgs(
+      declaration.dialogueGroup?.constructor.text ?? declaration.initializer.text
+    );
+    const kindArgument = args.get("kind");
+    const kind = kindArgument?.kind === "contextualEnum" ? SOURCE_DIALOGUE_GROUP_KINDS[kindArgument.name] : void 0;
+    const lookup = kind === "lookup" ? lookups.resolve(args.get("collection")) : void 0;
+    if (declaration.dialogueGroup)
+      contexts.set(
+        declaration,
+        dialogueGroupContext(
+          `dialogue-context:${uri}:${declaration.name}`,
+          lookup?.entryType
+        )
+      );
+    if (kind === void 0) continue;
+    const name = args.get("name");
+    sources2.push({
+      id: id2,
+      name: name?.kind === "litString" ? name.value : declaration.name,
+      parentId: referenceId(args.get("parent"), idsByName),
+      kind,
+      ...lookup ? { lookup } : {},
+      location: location(uri, declaration.range),
+      selectionLocation: location(uri, declaration.nameRange)
+    });
+  }
+  return { contexts, sources: sources2 };
+}
+function dialogueGroupContext(id2, thisType) {
+  return {
+    ...thisType ? { thisType } : {},
+    contextType: {
+      id: id2,
+      name: "DialogueContext",
+      kind: "synthetic",
+      members: [
+        {
+          id: `${id2}:primary`,
+          name: "primary",
+          kind: "property",
+          type: { kind: "primitive", name: "unknown" },
+          writable: false
+        },
+        {
+          id: `${id2}:trigger`,
+          name: "trigger",
+          kind: "property",
+          type: thisType ?? { kind: "primitive", name: "null" },
+          writable: false
+        }
+      ]
+    }
+  };
 }
 function compileBody(args) {
   args.contexts.push({
@@ -46233,7 +46842,7 @@ function compileBody(args) {
       uri: args.uri,
       source: "neo-project",
       code: projectBodyDiagnosticCode(diagnostic.message, args.unit),
-      message: `${capitalize(args.unit)} '${args.owner.declaration.name}.${args.memberName}': ${diagnostic.message}`,
+      message: `${capitalize2(args.unit)} '${args.owner.declaration.name}.${args.memberName}': ${diagnostic.message}`,
       relatedInformation: [
         {
           location: location(args.uri, args.declarationRange),
@@ -46779,7 +47388,7 @@ function projectRootType(documents, declarations) {
       }
     }
   }
-  return { id: "builtin:Root", name: "Root", kind: "synthetic", members };
+  return { id: PROJECT_ROOT_TYPE_ID, name: "Root", kind: "synthetic", members };
 }
 function sourceTypeRef(type, owner, typeIds, resolvingTypeParameters = /* @__PURE__ */ new Set()) {
   const nullable2 = type.nullable || void 0;
@@ -46792,9 +47401,11 @@ function sourceTypeRef(type, owner, typeIds, resolvingTypeParameters = /* @__PUR
     };
   }
   if (type.name === "Set") {
+    const element = type.typeArguments[0];
     return {
       kind: "set",
-      elementType: type.typeArguments[0] ? resolveNested(type.typeArguments[0]) : { kind: "primitive", name: "unknown" },
+      // P105 §2.2. Multiselect dialogue elements are bare dialogue ids.
+      elementType: element?.name === "NeoDialogueReference" ? { kind: "primitive", name: "string" } : element ? resolveNested(element) : { kind: "primitive", name: "unknown" },
       ...nullable2 ? { nullable: nullable2 } : {}
     };
   }
@@ -46996,16 +47607,15 @@ function sourceIdentity2(annotations, fallback) {
 function location(uri, range2) {
   return { uri, range: range2 };
 }
-function capitalize(value) {
+function capitalize2(value) {
   return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
 }
-var PRIMITIVE_NAME_LIST, PRIMITIVE_NAMES, STORAGE_WRITABILITY, successfulBodiesByProject;
+var PRIMITIVE_NAME_LIST, PRIMITIVE_NAMES, STORAGE_WRITABILITY, successfulBodiesByProject, SOURCE_DIALOGUE_GROUP_KINDS, SourceDialogueGroupLookups, PROJECT_ROOT_TYPE_ID;
 var init_project_source_script_compiler = __esm({
   "../packages/neoscript-language/src/project-source-script-compiler.ts"() {
     "use strict";
     init_project_source_settlement();
     init_debug_info();
-    init_executable_parser();
     init_compiler();
     init_declared_constructors();
     init_language_spec();
@@ -47016,13 +47626,15 @@ var init_project_source_script_compiler = __esm({
     init_project_source_registry();
     init_source_text();
     init_lexer();
+    init_dialogue_types();
+    init_project_source_dialogue_groups();
     PRIMITIVE_NAME_LIST = [
       ...NEOSCRIPT_PRIMITIVE_TYPES,
       "void",
       "null",
       "SpriteInfo",
       "AudioClipInfo",
-      "DialogueRef",
+      "NeoDialogueReference",
       "Vector2",
       "Vector2Int",
       "Vector3",
@@ -47036,6 +47648,46 @@ var init_project_source_script_compiler = __esm({
       User: "user"
     };
     successfulBodiesByProject = /* @__PURE__ */ new Map();
+    SOURCE_DIALOGUE_GROUP_KINDS = { Standard: "standard", Lookup: "lookup", Folder: "folder" };
+    SourceDialogueGroupLookups = class {
+      constructor(graph) {
+        this.graph = graph;
+      }
+      graph;
+      index;
+      membersByType;
+      resolve(collection) {
+        let member;
+        if (collection?.kind === "member" && collection.receiver.kind === "ident") {
+          member = (this.membersByType ??= new Map(
+            this.graph.project.types.map((type) => [
+              type.name,
+              new Map(type.members.map((candidate) => [candidate.name, candidate]))
+            ])
+          )).get(collection.receiver.name)?.get(collection.name);
+        } else if (collection?.kind === "call" && collection.callee.kind === "ident" && collection.callee.name === "Reference") {
+          const id2 = collection.args[collection.argumentNames?.indexOf("id") ?? -1];
+          if (id2?.kind === "litString")
+            member = this.projectIndex().symbolById.get(id2.value);
+        }
+        if (member === void 0) return void 0;
+        let entry;
+        if (member.type.kind === "list") entry = member.type.elementType;
+        if (member.type.kind === "dictionary") entry = member.type.valueType;
+        if (entry?.kind !== "named") return void 0;
+        const entryTypeName = this.projectIndex().typeById.get(entry.typeId)?.name;
+        if (entryTypeName === void 0) return void 0;
+        return {
+          collection: member.name,
+          entryType: { ...entry, nullable: false },
+          entryTypeName
+        };
+      }
+      projectIndex() {
+        return this.index ??= createProjectIndex(this.graph.project);
+      }
+    };
+    PROJECT_ROOT_TYPE_ID = "builtin:Root";
   }
 });
 
@@ -48028,7 +48680,7 @@ function validateClassOverrides(ref, environment, diagnostics) {
     }
     const target = candidates[candidates.length - 1];
     if (!target) {
-      const isDialogueTriggerOverride = ref.declaration.baseTypes.some((base) => base.name === "Dialogue") && member.kind === "field" && member.name === "Trigger" && member.type.name === "Trigger";
+      const isDialogueTriggerOverride = ref.declaration.baseTypes.some((base) => base.name === "NeoDialogue") && member.kind === "field" && member.name === "Trigger" && member.type.name === "Trigger";
       if (isDialogueTriggerOverride) continue;
       const opaqueBase = ref.declaration.baseTypes.find(
         (base) => BUILTIN_TYPES.has(base.name) && !environment.declarations.has(base.name)
@@ -48841,9 +49493,9 @@ var init_project_source_type_checker = __esm({
       "AudioTemplate",
       "Localization",
       "LocalizationStatus",
-      "PriorityGroup",
-      "PriorityOption",
-      "DialogueGroup",
+      "NeoPriorityGroup",
+      "NeoPriorityOption",
+      "NeoDialogueGroup",
       "ImageRegistry",
       "AudioClipRegistry",
       "NeoImage",
@@ -49122,6 +49774,7 @@ function analyzeNeoProjectSources(inputs, parsedDocuments = /* @__PURE__ */ new
   }
   validateSymbolUniqueness(symbols, diagnostics);
   diagnostics.push(...validateDialogueGroupPaths({ documents, symbols }));
+  diagnostics.push(...validateDialogueGroupNames({ documents, symbols }));
   diagnostics.push(...validateLocalValueInitializers(documents));
   diagnostics.push(...validateVariantDeclarations(documents));
   validateSystemAnnotationAuthoring(documents, diagnostics);
@@ -49295,7 +49948,18 @@ function collectDeclarationSymbols(uri, document, declaration, symbols, diagnost
 }
 function collectGlobalChildSymbols(uri, document, declaration, symbols, diagnostics) {
   if (declaration.type.name === "Root") return;
+  const priorityGroup = declaration.type.name === "NeoPriorityGroup";
   for (const entry of collectGlobalChildEntries(document.syntax, declaration)) {
+    if (priorityGroup && entry.typeName !== "NeoPriorityOption") {
+      diagnostics.push({
+        uri,
+        range: entry.typeRange,
+        severity: "error",
+        source: "neo-project",
+        code: "unknown-project-type",
+        message: renamedDialogueTypeMessage(entry.typeName, "value") ?? `Priority group options are declared as \`NeoPriorityOption\`, not \`${entry.typeName}\`.`
+      });
+    }
     collectSymbol(
       uri,
       "graphChild",
@@ -49625,7 +50289,7 @@ function validateTypeReferences(documents, symbols, diagnostics) {
         declaration.genericParameters.map((parameter4) => parameter4.name)
       ) : /* @__PURE__ */ new Set();
       for (const base of declaration.baseTypes) {
-        validateType(uri, base, generics, projectTypes, diagnostics);
+        validateType(uri, base, generics, projectTypes, diagnostics, "base");
       }
       if (declaration.kind === "class") {
         for (const parameter4 of declaration.genericParameters) {
@@ -49635,7 +50299,8 @@ function validateTypeReferences(documents, symbols, diagnostics) {
               parameter4.constraint,
               generics,
               projectTypes,
-              diagnostics
+              diagnostics,
+              "base"
             );
           }
         }
@@ -49699,7 +50364,7 @@ function validateMemberTypes(uri, owner, member, genericParameters, projectTypes
     });
   }
 }
-function validateType(uri, type, genericParameters, projectTypes, diagnostics) {
+function validateType(uri, type, genericParameters, projectTypes, diagnostics, position = "value") {
   if (!BUILTIN_TYPE_NAMES.has(type.name) && !genericParameters.has(type.name) && !projectTypes.has(type.name)) {
     diagnostics.push({
       uri,
@@ -49707,7 +50372,7 @@ function validateType(uri, type, genericParameters, projectTypes, diagnostics) {
       severity: "error",
       source: "neo-project",
       code: "unknown-project-type",
-      message: `Unknown project type '${type.name}'. Declare it in a top-level .neo file or correct the type name.`
+      message: renamedDialogueTypeMessage(type.name, position) ?? `Unknown project type '${type.name}'. Declare it in a top-level .neo file or correct the type name.`
     });
   }
   for (const argument2 of type.typeArguments) {
@@ -49740,6 +50405,7 @@ var BUILTIN_TYPE_NAMES, SYSTEM_RECORD_ID_PREFIX2, RFC_4122_UUID, QUARANTINED_LEG
 var init_project_source_analysis = __esm({
   "../packages/neoscript-language/src/project-source-analysis.ts"() {
     "use strict";
+    init_dialogue_types();
     init_project_source_dialogue_groups();
     init_project_local_values();
     init_language_spec();
@@ -49764,9 +50430,9 @@ var init_project_source_analysis = __esm({
       "AudioTemplate",
       "Localization",
       "LocalizationStatus",
-      "PriorityGroup",
-      "PriorityOption",
-      "DialogueGroup",
+      "NeoPriorityGroup",
+      "NeoPriorityOption",
+      "NeoDialogueGroup",
       "ImageRegistry",
       "AudioClipRegistry",
       "NeoImage",
@@ -50910,7 +51576,7 @@ var init_project_source_manifest = __esm({
     ]);
     FILE_REGISTRY_TYPES = /* @__PURE__ */ new Set(["ImageRegistry", "AudioClipRegistry"]);
     FILE_DECLARATION_TYPES = /* @__PURE__ */ new Set(["NeoImage", "NeoAudioClip"]);
-    GROUP_TYPES = /* @__PURE__ */ new Set(["PriorityGroup", "DialogueGroup"]);
+    GROUP_TYPES = /* @__PURE__ */ new Set(["NeoPriorityGroup", "NeoDialogueGroup"]);
     MIGRATION_TYPES = /* @__PURE__ */ new Set(["Migration"]);
   }
 });
@@ -50975,7 +51641,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.72.4",
+      cliVersion: "0.73.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -62280,7 +62946,7 @@ var init_ui_action_source = __esm({
 // src/project-source/dialogue-group-symbols.ts
 function authoredDialogueGroupSymbols(analysis) {
   return new Map(
-    analysis?.dialogueGroups.globals.filter((global) => global.type.name === "DialogueGroup").map((global) => [
+    analysis?.dialogueGroups.globals.filter((global) => global.type.name === "NeoDialogueGroup").map((global) => [
       global.id ?? `__pending__:dialogue-group:${encodeURIComponent(global.source.uri)}:${global.source.range.start.line}:${global.source.range.start.character}:${encodeURIComponent(global.name)}`,
       global.name
     ])
@@ -63453,7 +64119,7 @@ function memberSettings(context, member) {
   } else if (member.kind === "dialogueLookup") {
     if (member.dialogueGroupId) {
       settings.push(
-        `group: Reference<DialogueGroup>(id: ${quote(member.dialogueGroupId)})`
+        `group: Reference<NeoDialogueGroup>(id: ${quote(member.dialogueGroupId)})`
       );
     }
     if (member.multiselect) settings.push("selection: .Multi");
@@ -63605,7 +64271,7 @@ function renderMemberType(context, member, enclosingClassId, elementSettings = f
       break;
     }
     case "dialogueLookup":
-      value = member.multiselect ? "Set<Dialogue>" : "Dialogue";
+      value = member.multiselect ? "Set<NeoDialogueReference>" : "NeoDialogueReference";
       break;
     case "generic":
       value = genericName(context, member.genericParamId);
@@ -63702,7 +64368,7 @@ function renderType(context, type, enclosingClassId) {
       value = "Color";
       break;
     case "dialogueLookup":
-      value = "Dialogue";
+      value = "NeoDialogueReference";
       break;
     case "class": {
       const schemaClass2 = required(context.classes, type.classId, "class");
@@ -63896,11 +64562,7 @@ function renderDefaultValue(context, member, wrapper, enclosingClassId) {
     ).name;
   }
   if ((member.kind === "lookup" || member.kind === "dialogueLookup") && Array.isArray(value)) {
-    const renderedType = renderMemberType(
-      context,
-      member,
-      enclosingClassId
-    ).replace(/\?$/u, "");
+    const renderedType = referenceTargetType(context, member, enclosingClassId);
     const targetType = member.multiselect ? /^Set<(.+)>$/u.exec(renderedType)?.[1] ?? renderedType : renderedType;
     const refs = value.filter((entry) => typeof entry === "string").map((entry) => `Reference<${targetType}>(id: ${quote(entry)})`);
     if (refs.length === 0 && value.length === 0) return "[]";
@@ -63955,9 +64617,16 @@ function renderDefaultValue(context, member, wrapper, enclosingClassId) {
 function spriteFileSource(context, fileId) {
   return context.fileSymbols.get(fileId) ?? `Reference<NeoImage>(id: ${quote(fileId)})`;
 }
+function referenceTargetType(context, member, enclosingClassId) {
+  if (member.kind === "dialogueLookup") return "NeoDialogue";
+  return renderMemberType(context, member, enclosingClassId).replace(
+    /\?$/u,
+    ""
+  );
+}
 function renderNestedValue(context, member, value, enclosingClassId) {
   if (typeof value === "string" && member.kind !== "string" && member.kind !== "decimal" && member.kind !== "enum") {
-    return `Reference<${renderMemberType(context, member, enclosingClassId).replace(/\?$/, "")}>(id: ${quote(value)})`;
+    return `Reference<${referenceTargetType(context, member, enclosingClassId)}>(id: ${quote(value)})`;
   }
   return renderDefaultValue(
     context,
@@ -66239,7 +66908,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
   const storedStatic = declaration.modifiers.includes("static") && !declaration.modifiers.includes("readonly");
   const settings = annotation(declaration.annotations, "settings");
   const inherited = inheritedMember(context, commonInput.overrideOf);
-  const storesSelectionArray = context.enumIdsByName.has(fieldType.name) || fieldType.name === "Dialogue" || Boolean(settings && argument(settings, "collection"));
+  const storesSelectionArray = context.enumIdsByName.has(fieldType.name) || fieldType.name === "NeoDialogueReference" || Boolean(settings && argument(settings, "collection"));
   const common = {
     ...commonInput,
     // A stored static initializer authors the live value binding, never an
@@ -66435,7 +67104,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       assertNoElementSettings(fieldType, ownerClass, declaration, "enum");
       return { ...common, kind: "enum", enumId: enumId2, multiselect: true };
     }
-    if (entryType.name === "Dialogue" && multiselect) {
+    if (entryType.name === "NeoDialogueReference" && multiselect) {
       assertNoElementSettings(fieldType, ownerClass, declaration, "dialogue");
       return {
         ...common,
@@ -66504,7 +67173,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       }
     };
   }
-  if (name === "Dialogue") {
+  if (name === "NeoDialogueReference") {
     return {
       ...common,
       kind: "dialogueLookup",
@@ -67111,7 +67780,8 @@ function lowerType(context, type, ownerClass) {
       };
     }
   }
-  if (type.name === "Dialogue") return { kind: "dialogueLookup", nullable: nullable2 };
+  if (type.name === "NeoDialogueReference")
+    return { kind: "dialogueLookup", nullable: nullable2 };
   if (type.name === "object") return { kind: "unknown", nullable: nullable2 };
   throw new Error(`Unknown Neo type ${JSON.stringify(type.name)}.`);
 }
@@ -67910,7 +68580,7 @@ function manifestTypeForSchemaType(context, type) {
     case "vector3Int":
       return { name: "Vector3Int", nullable: nullable2, arguments: [] };
     case "dialogueLookup":
-      return { name: "Dialogue", nullable: nullable2, arguments: [] };
+      return { name: "NeoDialogueReference", nullable: nullable2, arguments: [] };
     case "color":
       return { name: "Color", nullable: nullable2, arguments: [] };
     case "class": {
@@ -69453,7 +70123,7 @@ function lowerSupplementalProjectRecordsV4(state, analysis, projectFileRecords)
     );
   }
   const priorityGlobals = analysis.dialogueGroups.globals.filter(
-    (global) => global.type.name === "PriorityGroup"
+    (global) => global.type.name === "NeoPriorityGroup"
   );
   const priorityIds = globalIds(priorityGlobals, "priority-group");
   for (const global of priorityGlobals) {
@@ -69468,7 +70138,7 @@ function lowerSupplementalProjectRecordsV4(state, analysis, projectFileRecords)
     );
   }
   const dialogueGlobals = analysis.dialogueGroups.globals.filter(
-    (global) => global.type.name === "DialogueGroup"
+    (global) => global.type.name === "NeoDialogueGroup"
   );
   const dialogueIds = globalIds(dialogueGlobals, "dialogue-group");
   const uiLogicResolver = analysisUILogicResolver(analysis);
@@ -69514,7 +70184,7 @@ function emitProjectGlobal(data, textureNames, audioNames, priorityNames) {
     ],
     [
       "defaultPriorityGroup",
-      reference(data.defaultPriorityGroupId, priorityNames, "PriorityGroup")
+      reference(data.defaultPriorityGroupId, priorityNames, "NeoPriorityGroup")
     ]
   ].filter((entry) => entry[1] !== null);
   return `Project Project = new(${args.length === 0 ? "" : `
@@ -69533,14 +70203,14 @@ function emitPriorityGroup(data, recordId, name) {
     }
     assertMemberIdentifier2(option.name, "priority option");
     return `  @id(${quote2(option.id)})
-  PriorityOption ${option.name} = new();`;
+  NeoPriorityOption ${option.name} = new();`;
   });
   const annotations = [
     `@id(${quote2(recordId)})`,
     ...isObjectRecord2(data.system) ? [emitSystemAnnotation(data.system)] : []
   ];
   return `${annotations.join("\n")}
-PriorityGroup ${name} = new() {
+NeoPriorityGroup ${name} = new() {
 ${body.join("\n\n")}
 }
 `;
@@ -69554,13 +70224,13 @@ function emitDialogueGroup(data, recordId, name, priorityNames, dialogueNames, u
   const priority = reference(
     data.priorityGroupIdOverride,
     priorityNames,
-    "PriorityGroup"
+    "NeoPriorityGroup"
   );
   if (priority) args.push(["priorityGroup", priority]);
   const parent = reference(
     data.parentDialogueGroupId,
     dialogueNames,
-    "DialogueGroup"
+    "NeoDialogueGroup"
   );
   if (parent) args.push(["parent", parent]);
   if (typeof data.collectionMemberId === "string") {
@@ -69585,7 +70255,7 @@ function emitDialogueGroup(data, recordId, name, priorityNames, dialogueNames, u
 ${args.map(([argument2, value]) => `  ${argument2}: ${value},`).join("\n")}
 )`;
   return `@id(${quote2(recordId)})
-DialogueGroup ${name} = ${constructor2}${body.length > 0 ? ` {
+NeoDialogueGroup ${name} = ${constructor2}${body.length > 0 ? ` {
 ${body.map((entry) => indentNeoSource(entry, 2)).join("\n\n")}
 }` : ";"}
 `;
@@ -69629,7 +70299,7 @@ function collectDialogueGroupFunctions(data, groupId, resolver) {
       const existing = functions.get(functionId);
       if (existing.code !== code) {
         throw new Error(
-          `DialogueGroup function ${functionId} has divergent persisted uses.`
+          `NeoDialogueGroup function ${functionId} has divergent persisted uses.`
         );
       }
     }
@@ -69646,7 +70316,7 @@ function requiredStringField(value, field, owner) {
 }
 function emitDialogueGroupFunction(fn) {
   if (fn.id === null) {
-    throw new Error(`Pulled DialogueGroup function ${fn.name} has no id.`);
+    throw new Error(`Pulled NeoDialogueGroup function ${fn.name} has no id.`);
   }
   const annotation2 = `@id(${quote2(fn.id)})`;
   if (fn.code === null) {
@@ -69664,7 +70334,7 @@ function emitDialogueGroupUseList(uses) {
 ${uses.map((use) => {
     if (use.id === null) {
       throw new Error(
-        `Pulled DialogueGroup condition ${use.functionName} has no id.`
+        `Pulled NeoDialogueGroup condition ${use.functionName} has no id.`
       );
     }
     return `  @id(${quote2(use.id)})
@@ -69699,7 +70369,7 @@ function lowerProjectGlobal(baseValue, global, analysis) {
       args.get("defaultPriorityGroup"),
       globalIds(
         analysis.dialogueGroups.globals.filter(
-          (entry) => entry.type.name === "PriorityGroup"
+          (entry) => entry.type.name === "NeoPriorityGroup"
         ),
         "priority-group"
       )
@@ -69714,7 +70384,7 @@ function lowerPriorityGroup(baseValue, global) {
   const initializer = global.initializer.trim();
   const bodyMatch = /^new\s*\(\s*\)\s*\{([\s\S]*)\}$/.exec(initializer);
   if (!bodyMatch) {
-    throw new Error(`PriorityGroup ${global.name} must use new() { ... }.`);
+    throw new Error(`NeoPriorityGroup ${global.name} must use new() { ... }.`);
   }
   let body = bodyMatch[1];
   while (body.trim().length > 0) {
@@ -69723,16 +70393,20 @@ function lowerPriorityGroup(baseValue, global) {
     const match = PRIORITY_OPTION_PATTERN.exec(body);
     if (!match) {
       throw new Error(
-        `PriorityGroup ${global.name} contains an unsupported option declaration near ${JSON.stringify(body.slice(0, 80))}.`
+        `NeoPriorityGroup ${global.name} contains an unsupported option declaration near ${JSON.stringify(body.slice(0, 80))}.`
       );
     }
     const name = match[2];
     const id2 = match[1] ? JSON.parse(`"${match[1]}"`) : `__pending__:priority-option:${encodeURIComponent(globalId(global, "priority-group"))}:${encodeURIComponent(name)}`;
     if (seenNames.has(name)) {
-      throw new Error(`PriorityGroup ${global.name} repeats option ${name}.`);
+      throw new Error(
+        `NeoPriorityGroup ${global.name} repeats option ${name}.`
+      );
     }
     if (seenIds.has(id2)) {
-      throw new Error(`PriorityGroup ${global.name} repeats option id ${id2}.`);
+      throw new Error(
+        `NeoPriorityGroup ${global.name} repeats option id ${id2}.`
+      );
     }
     seenNames.add(name);
     seenIds.add(id2);
@@ -69762,14 +70436,14 @@ function sourceDialogueGroupType(global) {
   const authored = parseDialogueGroupInitializer(global.initializer);
   return dialogueGroupType(
     global.name,
-    constructorArguments(authored.constructor, "DialogueGroup")
+    constructorArguments(authored.constructor, "NeoDialogueGroup")
   );
 }
 function dialogueGroupType(name, args) {
   const kind = args.get("kind");
   if (kind?.kind !== "contextualEnum") {
     throw new Error(
-      `DialogueGroup ${name} requires kind: .Standard, .Lookup, or .Folder.`
+      `NeoDialogueGroup ${name} requires kind: .Standard, .Lookup, or .Folder.`
     );
   }
   const type = kind.name === "Lookup" ? 1 /* Lookup */ : kind.name === "Folder" ? 2 /* Folder */ : kind.name === "Standard" ? 0 /* Standard */ : null;
@@ -69780,7 +70454,7 @@ function dialogueGroupType(name, args) {
 function dialogueGroupDisplayName(expression, symbol) {
   if (expression?.kind !== "litString" || expression.value.trim().length === 0)
     throw new Error(
-      `DialogueGroup ${symbol} name must be a non-empty string literal.`
+      `NeoDialogueGroup ${symbol} name must be a non-empty string literal.`
     );
   return expression.value;
 }
@@ -69790,7 +70464,7 @@ function lowerDialogueGroup(baseValue, global, priorityIds, dialogueIds, uiLogic
   Reflect.deleteProperty(baseWithoutLookup, "collectionMemberId");
   Reflect.deleteProperty(baseWithoutLookup, "collectionValueId");
   const authored = parseDialogueGroupInitializer(global.initializer);
-  const args = constructorArguments(authored.constructor, "DialogueGroup");
+  const args = constructorArguments(authored.constructor, "NeoDialogueGroup");
   const type = dialogueGroupType(global.name, args);
   const collection = args.get("collection");
   let collectionMemberId;
@@ -69858,7 +70532,7 @@ function lowerDialogueGroupConditions(base, global, authored, uiLogicResolver) {
   for (const fn of authored.functions) {
     if (functions.has(fn.name)) {
       throw new Error(
-        `DialogueGroup ${global.name} repeats function ${fn.name}.`
+        `NeoDialogueGroup ${global.name} repeats function ${fn.name}.`
       );
     }
     functions.set(fn.name, fn);
@@ -69874,14 +70548,14 @@ function lowerDialogueGroupConditions(base, global, authored, uiLogicResolver) {
     );
     if (usedIds.has(id2)) {
       throw new Error(
-        `DialogueGroup ${global.name} repeats condition id ${id2}.`
+        `NeoDialogueGroup ${global.name} repeats condition id ${id2}.`
       );
     }
     usedIds.add(id2);
     const fn = functions.get(use.functionName);
     if (!fn) {
       throw new Error(
-        `DialogueGroup ${global.name} condition ${use.functionName} has no body function.`
+        `NeoDialogueGroup ${global.name} condition ${use.functionName} has no body function.`
       );
     }
     usedFunctions.add(fn.name);
@@ -69919,7 +70593,7 @@ function lowerDialogueGroupConditions(base, global, authored, uiLogicResolver) {
   for (const fn of authored.functions) {
     if (!usedFunctions.has(fn.name)) {
       throw new Error(
-        `DialogueGroup ${global.name} function ${fn.name} is not referenced by when.`
+        `NeoDialogueGroup ${global.name} function ${fn.name} is not referenced by when.`
       );
     }
   }
@@ -70000,12 +70674,12 @@ function parseDialogueGroupInitializer(initializer) {
     }
   }
   if (closeIndex < 0) {
-    throw new Error("DialogueGroup initializer has an unclosed body.");
+    throw new Error("NeoDialogueGroup initializer has an unclosed body.");
   }
   const close = tokens[closeIndex];
   const trailing = tokens.slice(closeIndex + 1);
   if (trailing.length > 1 || trailing[0] && trailing[0].text !== ";") {
-    throw new Error("Nothing may follow a DialogueGroup body.");
+    throw new Error("Nothing may follow a NeoDialogueGroup body.");
   }
   let depth = 0;
   let whenIndex = -1;
@@ -70015,7 +70689,7 @@ function parseDialogueGroupInitializer(initializer) {
     else if (token.text === "}") depth -= 1;
     else if (depth === 0 && token.text === "when") {
       if (whenIndex >= 0) {
-        throw new Error("DialogueGroup body may declare when only once.");
+        throw new Error("NeoDialogueGroup body may declare when only once.");
       }
       whenIndex = index;
     }
@@ -70026,7 +70700,7 @@ function parseDialogueGroupInitializer(initializer) {
   if (whenIndex < 0) {
     if (parsedFunctions.length > 0) {
       throw new Error(
-        "DialogueGroup body functions require a final when: [...] use list."
+        "NeoDialogueGroup body functions require a final when: [...] use list."
       );
     }
     return {
@@ -70038,7 +70712,7 @@ function parseDialogueGroupInitializer(initializer) {
   const colon = tokens[whenIndex + 1];
   if (colon?.text !== ":") {
     throw new Error(
-      "DialogueGroup condition uses must be written as when: [...]."
+      "NeoDialogueGroup condition uses must be written as when: [...]."
     );
   }
   let parenDepth = 0;
@@ -70059,10 +70733,12 @@ function parseDialogueGroupInitializer(initializer) {
     }
   }
   if (semicolonIndex < 0) {
-    throw new Error("DialogueGroup when: [...] must end with a semicolon.");
+    throw new Error("NeoDialogueGroup when: [...] must end with a semicolon.");
   }
   if (tokens.slice(semicolonIndex + 1, closeIndex).length > 0) {
-    throw new Error("DialogueGroup when: [...] must be the final body entry.");
+    throw new Error(
+      "NeoDialogueGroup when: [...] must be the final body entry."
+    );
   }
   const semicolon = tokens[semicolonIndex];
   return {
@@ -70084,17 +70760,17 @@ function parseDialogueGroupFunctions(source) {
   );
   if (errors.length > 0) {
     throw new Error(
-      `Invalid DialogueGroup body: ${errors.map((diagnostic) => diagnostic.message).join(" ")}`
+      `Invalid NeoDialogueGroup body: ${errors.map((diagnostic) => diagnostic.message).join(" ")}`
     );
   }
   const declaration = parsed.declarations[0];
   if (declaration?.kind !== "class") {
-    throw new Error("DialogueGroup body could not be parsed.");
+    throw new Error("NeoDialogueGroup body could not be parsed.");
   }
   return declaration.members.map((member) => {
     if (member.kind !== "function") {
       throw new Error(
-        "DialogueGroup bodies may contain only zero-argument bool functions and a final when: [...] list."
+        "NeoDialogueGroup bodies may contain only zero-argument bool functions and a final when: [...] list."
       );
     }
     assertDialogueGroupFunctionSignature(member);
@@ -70108,19 +70784,19 @@ function parseDialogueGroupFunctions(source) {
 function assertDialogueGroupFunctionSignature(member) {
   if (member.type.name !== "bool" || member.type.nullable || member.type.typeArguments.length > 0 || member.parameters.length > 0 || member.modifiers.includes("async")) {
     throw new Error(
-      `DialogueGroup function ${member.name} must be a synchronous zero-argument bool function.`
+      `NeoDialogueGroup function ${member.name} must be a synchronous zero-argument bool function.`
     );
   }
   if (member.body === void 0 && !member.modifiers.includes("native")) {
     throw new Error(
-      `DialogueGroup function ${member.name} requires a body or the native modifier.`
+      `NeoDialogueGroup function ${member.name} requires a body or the native modifier.`
     );
   }
 }
 function parseDialogueGroupUseList(expression) {
   const trimmed = expression.trim();
   if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
-    throw new Error("DialogueGroup when uses must use bracket list syntax.");
+    throw new Error("NeoDialogueGroup when uses must use bracket list syntax.");
   }
   const body = trimmed.slice(1, -1);
   const pattern = /\s*(?:@id\(\s*("(?:[^"\\]|\\.)*")\s*\)\s*)?([A-Za-z_][A-Za-z0-9_]*)\s*(?:,|$)/gy;
@@ -70132,7 +70808,7 @@ function parseDialogueGroupUseList(expression) {
     if (!match) {
       if (body.slice(consumed).trim().length === 0) break;
       throw new Error(
-        `Invalid DialogueGroup condition-use list near ${JSON.stringify(body.slice(consumed))}.`
+        `Invalid NeoDialogueGroup condition-use list near ${JSON.stringify(body.slice(consumed))}.`
       );
     }
     result.push({
@@ -70149,7 +70825,7 @@ function annotationId(annotations) {
   const parsed = JSON.parse(expression);
   if (typeof parsed !== "string" || parsed.length === 0) {
     throw new Error(
-      "DialogueGroup function @id must contain a non-empty string."
+      "NeoDialogueGroup function @id must contain a non-empty string."
     );
   }
   return parsed;
@@ -70410,7 +71086,7 @@ var init_supplemental_records = __esm({
     init_project_file_source();
     init_source_format();
     init_ui_action_source();
-    PRIORITY_OPTION_PATTERN = /^(?:@id\(\s*"((?:[^"\\]|\\.)+)"\s*\)\s*)?PriorityOption\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*new\s*\(\s*\)\s*;/;
+    PRIORITY_OPTION_PATTERN = /^(?:@id\(\s*"((?:[^"\\]|\\.)+)"\s*\)\s*)?[A-Za-z_][A-Za-z0-9_]*\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*new\s*\(\s*\)\s*;/;
   }
 });
 
@@ -70441,7 +71117,7 @@ function builtinTextVariableMember(receiver, name) {
 function createDialogueLoweringIndexesV4(state, analysis, options = {}) {
   const mainLocale = readMainLocale(state);
   const dialogueGroups = analysis.dialogueGroups.globals.filter(
-    (global) => global.type.name === "DialogueGroup"
+    (global) => global.type.name === "NeoDialogueGroup"
   );
   const dialogueGroupIds = globalIds2(dialogueGroups, "dialogue-group");
   const lookupDialogueGroupIds = new Set(
@@ -71819,7 +72495,7 @@ function lowerDialogueGroupSettings(context, member, base) {
   const expression = constructorExpression(member.arguments, "group");
   if (expression === null) return null;
   const old = isObjectRecord2(base.dialogueGroupSettings) ? base.dialogueGroupSettings : {};
-  const referencedGroupId = referenceId3(expression, "DialogueGroup");
+  const referencedGroupId = referenceId3(expression, "NeoDialogueGroup");
   if (referencedGroupId !== null) {
     if (!context.groupPaths.byId.has(referencedGroupId)) {
       throw dialogueSourceError(
@@ -71835,10 +72511,10 @@ function lowerDialogueGroupSettings(context, member, base) {
       member.arguments,
       "priority"
     );
-    const priorityOptionId = priorityExpression === null ? null : referenceId3(priorityExpression, "PriorityOption");
+    const priorityOptionId = priorityExpression === null ? null : referenceId3(priorityExpression, "NeoPriorityOption");
     if (priorityExpression !== null && priorityOptionId === null) {
       throw dialogueSourceError(
-        'Trigger priority must be authored as Reference<PriorityOption>(id: "...").',
+        'Trigger priority must be authored as Reference<NeoPriorityOption>(id: "...").',
         prioritySource
       );
     }
@@ -72723,7 +73399,7 @@ var init_dialogue_lower = __esm({
             required: required2
           };
         }
-        if (type.name === "Dialogue") {
+        if (type.name === "NeoDialogueReference") {
           return { type: 18 /* DialogueLookup */, required: required2 };
         }
         return null;
@@ -72864,7 +73540,8 @@ function projectSchemaManifest(input, options = {}) {
       (item, index) => enumType(item, environment, `enums[${index}]`)
     )
   ];
-  const rootType = createRootType(rootMemberIds, environment);
+  const dialogues = neoScriptDialogueTypes(options.dialogueGroups ?? []);
+  const rootType = createRootType(rootMemberIds, environment, dialogues.member);
   declaredTypes.push(rootType);
   const roots = options.roots ?? [
     {
@@ -72883,7 +73560,7 @@ function projectSchemaManifest(input, options = {}) {
   return {
     project: {
       version: options.version ?? `manifest:${nextManifestProjectionVersion++}`,
-      types: languageTypes,
+      types: [...languageTypes, ...dialogues.types],
       globals: options.globals ?? [],
       roots,
       listIndexes: members.flatMap(
@@ -73018,7 +73695,7 @@ function staticDefaultWritability(classId, environment) {
     resolvedAllowedStorage(classId, environment)
   );
 }
-function createRootType(ids, environment) {
+function createRootType(ids, environment, dialogues) {
   const definitions = [
     ["Assets", ids.assets, false, "immutable"],
     ["Save", ids.save, true, "save"],
@@ -73041,6 +73718,7 @@ function createRootType(ids, environment) {
       ...sourceLocation(member.source, environment, `root.${name}.source`)
     });
   }
+  members.push(dialogues);
   return {
     id: "__root__",
     name: "Root",
@@ -73817,8 +74495,7 @@ function memberType(member, environment, visiting, field) {
     return member.multiselect === true ? { kind: "set", elementType: entryType, nullable: nullable2 } : { ...entryType, nullable: nullable2 };
   }
   if (kind === "dialogueLookup") {
-    const dialogue = primitive("DialogueRef", false);
-    return member.multiselect === true ? { kind: "set", elementType: dialogue, nullable: nullable2 } : { ...dialogue, nullable: nullable2 };
+    return member.multiselect === true ? { kind: "set", elementType: primitive("string", false), nullable: nullable2 } : { ...primitive("NeoDialogueReference", false), nullable: nullable2 };
   }
   if (kind === "computed") {
     return manifestType2(member.returnType, environment, `${field}.returnType`);
@@ -74300,7 +74977,7 @@ function manifestPrimitive(kind) {
     case "vector3Int":
       return "Vector3Int";
     case "dialogueLookup":
-      return "DialogueRef";
+      return "NeoDialogueReference";
     case "color":
       return "Color";
     default:
@@ -74467,6 +75144,7 @@ var init_project_schema_manifest = __esm({
     init_project2();
     init_project2();
     init_language_spec();
+    init_dialogue_types();
     nextManifestProjectionVersion = 1;
   }
 });
@@ -74598,6 +75276,58 @@ var init_interface_types = __esm({
   }
 });
 
+// ../src/models/dialogue/dialogue-group-language.ts
+function dialogueGroupLanguageContract(group) {
+  return {
+    id: group.id,
+    name: group.name,
+    type: group.type,
+    parentDialogueGroupId: group.parentDialogueGroupId ?? null,
+    collectionMemberId: group.type === 1 /* Lookup */ ? group.collectionMemberId : null
+  };
+}
+function storedDialogueGroupSources(groups, memberById2, classById) {
+  const sources2 = [];
+  for (const group of groups) {
+    const lookup = group.type === 1 /* Lookup */ ? lookupEntry(group.collectionMemberId, memberById2, classById) : void 0;
+    sources2.push({
+      id: group.id,
+      name: group.name,
+      parentId: group.parentDialogueGroupId ?? null,
+      kind: KINDS[group.type],
+      ...lookup ? { lookup } : {}
+    });
+  }
+  return sources2;
+}
+function lookupEntry(collectionMemberId, memberById2, classById) {
+  const collection = memberById2(collectionMemberId);
+  if (!isMemberListBase(collection) && !isMemberDictionaryBase(collection))
+    return void 0;
+  const entry = memberById2(collection.entryMemberId);
+  if (!isMemberClassBase(entry)) return void 0;
+  const entryClass = classById(entry.classId);
+  if (!entryClass) return void 0;
+  return {
+    collection: collection.name,
+    entryType: { kind: "named", typeId: entryClass.id },
+    entryTypeName: entryClass.name
+  };
+}
+var KINDS;
+var init_dialogue_group_language = __esm({
+  "../src/models/dialogue/dialogue-group-language.ts"() {
+    "use strict";
+    init_members();
+    init_dialogue_group_types();
+    KINDS = {
+      [0 /* Standard */]: "standard",
+      [1 /* Lookup */]: "lookup",
+      [2 /* Folder */]: "folder"
+    };
+  }
+});
+
 // ../src/runtime/neoscript/analyzer-types.ts
 function createAnalyzerSchemaIndex(context) {
   return projectSchemaIndexFor({
@@ -74817,8 +75547,15 @@ function createNeoScriptProjectInScope(context) {
       })
     });
   }
-  const rootType = createRootType2(context);
-  languageTypes.push(rootType);
+  const dialogues = neoScriptDialogueTypes(
+    storedDialogueGroupSources(
+      context.vm.dialogueGroups ?? [],
+      (id2) => analyzerMemberById(context, id2),
+      (id2) => analyzerSchemaIndex(context).classesById.get(id2)
+    )
+  );
+  const rootType = createRootType2(context, dialogues.member);
+  languageTypes.push(rootType, ...dialogues.types);
   if (context.dialogueContext) {
     languageTypes.push(createDialogueContextType(context));
   }
@@ -75346,7 +76083,7 @@ function interfaceMemberToSymbol(neoInterface, key, member, context, inherited)
     ...inheritedFrom ? { inheritedFrom } : {}
   };
 }
-function createRootType2(context) {
+function createRootType2(context, dialogues) {
   const members = [];
   for (const [index, root] of PROJECT_ROOTS.entries()) {
     const name = root.key;
@@ -75371,6 +76108,7 @@ function createRootType2(context) {
       )
     });
   }
+  members.push(dialogues);
   return {
     id: AnalyzerRootClassId,
     name: "Root",
@@ -75473,11 +76211,11 @@ function memberRuntimeType(record7, context, seen = /* @__PURE__ */ new Set(), g
       if (isMemberDialogueLookupBase(member) && isMultiSelectionMember(member)) {
         return {
           kind: "set",
-          elementType: primitive2("DialogueRef", true),
+          elementType: primitive2("string", true),
           nullable: !required2
         };
       }
-      return primitive2("DialogueRef", required2);
+      return primitive2("NeoDialogueReference", required2);
     case 14 /* Vector2 */:
       return primitive2("Vector2", required2);
     case 15 /* Vector2Int */:
@@ -75725,7 +76463,7 @@ function toLanguageType(type, context, genericEnvironment) {
     case 12 /* Audio */:
       return primitive2("AudioClipInfo", required2);
     case 18 /* DialogueLookup */:
-      return primitive2("DialogueRef", required2);
+      return primitive2("NeoDialogueReference", required2);
     case 14 /* Vector2 */:
       return primitive2("Vector2", required2);
     case 15 /* Vector2Int */:
@@ -75925,7 +76663,9 @@ function projectLanguageVersion(context) {
     ...context.vm.projectFiles ?? [],
     // P43 §6. Editing a constructor's parameters changes what a `new Foo(…)`
     // call site resolves to, so an open editor's cached context must rebuild.
-    ...context.constructors ?? []
+    ...context.constructors ?? [],
+    // P105 §2.6. Group names, parents, and kinds shape `root.Dialogues`.
+    ...context.vm.dialogueGroups ?? []
   ];
   return [
     `adapter:${NEOSCRIPT_COMPILER_ADAPTER_REVISION}`,
@@ -76133,8 +76873,10 @@ var init_neoscript_language_context_adapter = __esm({
     init_variant_member();
     init_project_root_members();
     init_project_file_registry();
+    init_dialogue_types();
+    init_dialogue_group_language();
     init_analyzer_types();
-    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 5;
+    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 6;
     UNKNOWN_TYPE2 = {
       kind: "primitive",
       name: "unknown"
@@ -86405,6 +87147,26 @@ function evalFunction(fn, scope, ctx) {
       const pointer = evalPointer(fn.info.pointer, scope, ctx);
       return dialogueMemoryVisitCount(pointer, ctx) > 0;
     }
+    case "dialogueGroup" /* dialogueGroup */: {
+      if (fn.info.valuePointer !== void 0)
+        evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.onFinishPointer !== void 0)
+        evalPointer(fn.info.onFinishPointer, scope, ctx);
+      return false;
+    }
+    case "dialogue" /* dialogue */: {
+      const idPointer = fn.info.dialogueIdPointer;
+      const dialogueId = evalPointer(idPointer, scope, ctx);
+      if (dialogueId === null && idPointer.type === "keyOf" /* keyOf */ && idPointer.optional === true)
+        return null;
+      if (typeof dialogueId !== "string")
+        throw new NSGetterRuntimeError(
+          `${fn.info.op} needs a dialogue id string, but got ${dialogueId === null ? "null" : typeof dialogueId}.`
+        );
+      if (fn.info.onFinishPointer !== void 0)
+        evalPointer(fn.info.onFinishPointer, scope, ctx);
+      return false;
+    }
     case "vectorConstructor" /* vectorConstructor */: {
       return evalVectorConstructor(
         fn.info.vectorType,
@@ -95496,6 +96258,7 @@ function createAnalyzerProject(ctx) {
   return {
     project: ctx.project,
     projectFiles: [...ctx.projectFiles ?? []],
+    dialogueGroups: [...ctx.dialogueGroups ?? []],
     members,
     classes: [...ctx.classes],
     enums: [...ctx.enums],
@@ -96823,6 +97586,7 @@ function compileDelegateClosureValue(code, signature) {
   const compiled = compileNSGetter(`return ${code};`, {
     project: signature.project,
     projectFiles: [...signature.projectFiles ?? []],
+    dialogueGroups: signature.dialogueGroups ?? [],
     members: [...signature.members],
     classes: [...signature.classes],
     enums: [...signature.enums],
@@ -96908,6 +97672,7 @@ function compilationProjectContext(args, members = args.members) {
   return {
     project: args.project,
     projectFiles: args.projectFiles ?? [],
+    dialogueGroups: args.dialogueGroups ?? [],
     members: [...members],
     classes: [...args.classes],
     enums: [...args.enums],
@@ -97558,6 +98323,7 @@ function compilationProjectForDocument(document, state) {
   state.compilationProject ??= createNeoScriptCompilationProject({
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -97651,6 +98417,7 @@ function compileValueInitializerDependency(document, valueId, compilationProject
   compileValueRowInitializerBody({
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -97669,6 +98436,7 @@ function compileMemberInitializerDependency(document, memberId, compilationProje
   const compileArgs = {
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -98136,7 +98904,7 @@ function isDialogueProps(value) {
 function isDialogue(value) {
   return isDialogueProps(value);
 }
-var init_dialogue_types = __esm({
+var init_dialogue_types2 = __esm({
   "../src/models/dialogue/dialogue-types.ts"() {
     "use strict";
     init_core_types();
@@ -99462,7 +100230,7 @@ var init_project_document_read = __esm({
     init_constructors2();
     init_variants();
     init_dialogue_group_types();
-    init_dialogue_types();
+    init_dialogue_types2();
     init_priority_types();
     init_enum();
     init_neoscript();
@@ -99772,7 +100540,9 @@ function collectCompilerReferencesInto(value, field, ids, names, constructedClas
 function isCompilerReferenceField(field) {
   return /(?:member|class|enum|interface|constructor|variant)(?:Type)?Ids?$/i.test(
     field
-  ) || field === "baseTypeIds" || field === "collectionValueId" || field === "fileId" || field === "primaryLinkedValueId" || field === "recordIds" || field === "valueId";
+  ) || field === "baseTypeIds" || field === "collectionValueId" || field === "fileId" || // P105 §2.5. Dialogue-group calls name their group by `groupId`. The
+  // IR kind is new, so the derived-edge extractor version doesn't change.
+  field === "groupId" || field === "primaryLinkedValueId" || field === "recordIds" || field === "valueId";
 }
 function collectChangedContractIds(args) {
   const impactedIds = /* @__PURE__ */ new Set();
@@ -99802,7 +100572,26 @@ function collectChangedContractIds(args) {
   );
   const currentSchemaRecords = schemaRecordsByKind(args.currentDocument);
   const postSchemaRecords = schemaRecordsByKind(args.postDocument);
+  const currentGroups = new DialogueGroupTree(args.currentDocument);
+  const postGroups = new DialogueGroupTree(args.postDocument);
   for (const change of args.changes) {
+    if (change.recordKind === "dialogue-group") {
+      const current2 = currentGroups.byId.get(change.recordId);
+      const next2 = postGroups.byId.get(change.recordId);
+      if (current2 !== void 0 && next2 !== void 0 && canonicalJsonStringify(dialogueGroupLanguageContract(current2)) === canonicalJsonStringify(dialogueGroupLanguageContract(next2))) {
+        continue;
+      }
+      currentGroups.addSubtree(change.recordId, impactedIds);
+      postGroups.addSubtree(change.recordId, impactedIds);
+      for (const group of [current2, next2]) {
+        if (group !== void 0) {
+          impactedTypeNames.add(
+            generatedCSharpTypeName(group.name, "DialogueGroup")
+          );
+        }
+      }
+      continue;
+    }
     if (change.recordKind === "class" || change.recordKind === "enum" || change.recordKind === "interface") {
       const kind = change.recordKind;
       const current2 = currentSchemaRecords[kind].get(change.recordId);
@@ -100322,7 +101111,7 @@ function withoutFields(value, ignored) {
     Object.entries(value).filter(([field]) => !ignored.has(field))
   );
 }
-var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS, NO_PLACEMENTS, classPlacementIndexes;
+var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS, DialogueGroupTree, NO_PLACEMENTS, classPlacementIndexes;
 var init_neo_script_recompile_scope = __esm({
   "../src/database/neo-script-recompile-scope.ts"() {
     "use strict";
@@ -100330,6 +101119,8 @@ var init_neo_script_recompile_scope = __esm({
     init_neo_script_derived_bodies();
     init_canonical_json();
     init_lexer();
+    init_generated_csharp_identifiers();
+    init_dialogue_group_language();
     init_member_kind_enum();
     init_member_kinds();
     init_inheritance();
@@ -100363,6 +101154,31 @@ var init_neo_script_recompile_scope = __esm({
       "bodyMode",
       "uiAction"
     ]);
+    DialogueGroupTree = class {
+      byId = /* @__PURE__ */ new Map();
+      children = /* @__PURE__ */ new Map();
+      constructor(document) {
+        for (const group of document.dialogueGroups ?? []) {
+          this.byId.set(group.id, group);
+          const parentId = group.parentDialogueGroupId;
+          if (parentId === null || parentId === void 0) continue;
+          const siblings = this.children.get(parentId) ?? [];
+          siblings.push(group.id);
+          this.children.set(parentId, siblings);
+        }
+      }
+      addSubtree(id2, ids) {
+        ids.add(id2);
+        const queue = [id2];
+        for (const groupId of queue) {
+          for (const child2 of this.children.get(groupId) ?? []) {
+            if (ids.has(child2)) continue;
+            ids.add(child2);
+            queue.push(child2);
+          }
+        }
+      }
+    };
     NO_PLACEMENTS = /* @__PURE__ */ new Set();
     classPlacementIndexes = /* @__PURE__ */ new WeakMap();
   }
@@ -101198,7 +102014,7 @@ var init_project_record_validation = __esm({
     init_packed_value_record_validation();
     init_enum();
     init_interface_types();
-    init_dialogue_types();
+    init_dialogue_types2();
     init_dialogue_group_types();
     init_priority_types();
     init_files();
@@ -106009,6 +106825,7 @@ function resolveDialogueCompileContext(args) {
     classes: args.classes,
     enums: args.enums,
     interfaces: args.interfaces ?? [],
+    dialogueGroups: args.dialogueGroups,
     thisClass: resolveNeoSchemaClassFromTypeInfo(thisClass, args.classes),
     returnTypeInfo: args.returnTypeInfo,
     ...valueAliases.length ? { valueAliases } : {},
@@ -106078,6 +106895,7 @@ function resolveDialogueGroupCompileContext(args) {
     classes: args.classes,
     enums: args.enums,
     interfaces: args.interfaces ?? [],
+    dialogueGroups: args.dialogueGroups,
     thisClass,
     returnTypeInfo: args.returnTypeInfo,
     dialogueContext: {
@@ -106110,7 +106928,15 @@ function compileDialogueLogic(request, projectData, reuseProject) {
       "Invalid dialogue logic compile body: expected ICompileDialogueLogicRequest."
     );
   }
-  const { project, members, classes, values, enums, interfaces } = projectData;
+  const {
+    project,
+    members,
+    classes,
+    values,
+    enums,
+    interfaces,
+    dialogueGroups
+  } = projectData;
   if (request.target === 0 /* Condition */) {
     const ctx2 = request.dialogueGroup ? resolveDialogueGroupCompileContext({
       project,
@@ -106119,6 +106945,7 @@ function compileDialogueLogic(request, projectData, reuseProject) {
       values,
       enums,
       interfaces,
+      dialogueGroups,
       dialogueGroup: request.dialogueGroup,
       returnTypeInfo: { type: 1 /* Bool */, required: true }
     }) : resolveDialogueCompileContext({
@@ -106128,6 +106955,7 @@ function compileDialogueLogic(request, projectData, reuseProject) {
       values,
       enums,
       interfaces,
+      dialogueGroups,
       dialogue: request.dialogue ?? {},
       node: request.node,
       returnTypeInfo: { type: 1 /* Bool */, required: true }
@@ -106162,6 +106990,7 @@ function compileDialogueLogic(request, projectData, reuseProject) {
       values,
       enums,
       interfaces,
+      dialogueGroups,
       dialogue: request.dialogue ?? {},
       node: request.node,
       returnTypeInfo: sourceBacked ? request.textVariable.typeInfo : { type: 3 /* String */, required: true }
@@ -106191,6 +107020,7 @@ function compileDialogueLogic(request, projectData, reuseProject) {
     values,
     enums,
     interfaces,
+    dialogueGroups,
     dialogue: request.dialogue ?? {},
     node: request.node,
     returnTypeInfo: { type: 0 /* Null */, required: true }
@@ -108377,7 +109207,7 @@ var init_general_function_call_ir_source_recompile = __esm({
     "use strict";
     init_members();
     init_core();
-    init_dialogue_types();
+    init_dialogue_types2();
     init_logic_types();
     init_inheritance();
     init_project_content_hash();
@@ -108875,6 +109705,9 @@ function neoScriptCompilationProjectContract(document) {
       name: file.name,
       fileType: file.fileType
     })),
+    dialogueGroups: (document.dialogueGroups ?? []).map(
+      dialogueGroupLanguageContract
+    ),
     members: document.members.map(
       (member) => neoScriptMemberContractProjection(
         member
@@ -108925,6 +109758,7 @@ var init_project_fingerprint = __esm({
     "use strict";
     init_strict_ir();
     init_neo_script_recompile_scope();
+    init_dialogue_group_language();
     init_compiler_adapter();
   }
 });
@@ -113756,6 +114590,7 @@ function prepareServerOwnedValueInitializerBodies(args) {
     const compilationProject = cachedServerCompilationProject({
       project: document.project,
       projectFiles: document.projectFiles,
+      dialogueGroups: document.dialogueGroups,
       members: document.members,
       classes: document.classes,
       enums: document.enums,
@@ -113781,6 +114616,7 @@ function prepareServerOwnedValueInitializerBodies(args) {
     compileValueRowInitializerBody({
       project: document.project,
       projectFiles: document.projectFiles,
+      dialogueGroups: document.dialogueGroups,
       members: document.members,
       classes: document.classes,
       enums: document.enums,
@@ -113996,6 +114832,7 @@ function compileInlineDelegateConstructorArguments(args) {
       compiled[argumentKey] = compileDelegateClosureValue(argument2.code, {
         project: document.project,
         projectFiles: document.projectFiles,
+        dialogueGroups: document.dialogueGroups,
         members: document.members,
         classes: document.classes,
         enums: document.enums,
@@ -114045,6 +114882,7 @@ function createDelegateValueBodyCompiler(postDocument, targetIds) {
       compiled.value = compileDelegateClosureValue(row.value.code, {
         project: document.project,
         projectFiles: document.projectFiles,
+        dialogueGroups: document.dialogueGroups,
         members: document.members,
         classes: document.classes,
         enums: document.enums,
@@ -114225,6 +115063,7 @@ function prepareServerOwnedConstructorBodies(args) {
       ),
       project: document.project,
       projectFiles: document.projectFiles,
+      dialogueGroups: document.dialogueGroups,
       members: document.members,
       classes: document.classes,
       enums: document.enums,
@@ -114406,6 +115245,7 @@ function compileOneAuthoredMember(args) {
     scriptSources: args.scriptSources,
     project: args.document.project,
     projectFiles: args.document.projectFiles,
+    dialogueGroups: args.document.dialogueGroups,
     members: args.members,
     classes: args.document.classes,
     enums: args.document.enums,
@@ -123071,6 +123911,7 @@ function replayStoredConstructionV4(args) {
   const compilationProject = args.compilationProject ?? (args.compileDocumentBodies === true ? createNeoScriptCompilationProject({
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -123127,6 +123968,7 @@ function replayStoredConstructionV4(args) {
     compileValueRowInitializerBody({
       project: document.project,
       projectFiles: document.projectFiles,
+      dialogueGroups: document.dialogueGroups,
       members: document.members,
       classes: document.classes,
       enums: document.enums,
@@ -123198,6 +124040,7 @@ function compilePulledUncompiledConstructorsV4(document, compilationProject, rep
   const project = compilationProject ?? createNeoScriptCompilationProject({
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -123207,6 +124050,7 @@ function compilePulledUncompiledConstructorsV4(document, compilationProject, rep
   const compileArgs = {
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -123223,6 +124067,7 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
   const sharedCompilationProject = compilationProject ?? createNeoScriptCompilationProject({
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -123233,6 +124078,7 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
   const compileArgs = {
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -129560,7 +130406,7 @@ function validateReferenceContract(context, member, target, ownerValueId) {
       `Dialogue member ${member.name} requires a dialogue target.`
     );
   }
-  if (target.genericTypeName && target.genericTypeName !== "Dialogue" && target.genericTypeName !== target.typeName) {
+  if (target.genericTypeName && target.genericTypeName !== "NeoDialogue" && target.genericTypeName !== target.typeName) {
     throw new Error(
       `Reference<${target.genericTypeName}> does not accept dialogue ${target.id}.`
     );
@@ -129583,7 +130429,7 @@ function lookupEntryTypeName(context, member) {
   if (entry.kind === "class")
     return context.classes.get(entry.classId)?.name ?? null;
   if (entry.kind === "enum") return null;
-  if (entry.kind === "dialogueLookup") return "Dialogue";
+  if (entry.kind === "dialogueLookup") return "NeoDialogueReference";
   return entry.kind;
 }
 function referenceTypeNameAssignable(context, actualName, expectedName) {
@@ -130105,7 +130951,7 @@ function freshConstructionReplaysDeclaredDefault(resolved, child2, defaultValue)
 function classMemberByName(context, classId, name) {
   const memberId = classMemberIdByName(context, classId, name);
   if (memberId !== null) return requiredMember(context, memberId);
-  throw new Error(
+  throw new MissingStoredMemberError(
     `Class ${context.classes.get(classId)?.name ?? classId} has no stored member ${name}.`
   );
 }
@@ -131711,7 +132557,7 @@ function storedSchemaTypeName(context, type, environment, valueId) {
     case "lookup":
       return storedSchemaTypeName(context, type.entryType, environment);
     case "dialogueLookup":
-      return "Dialogue";
+      return "NeoDialogueReference";
     case "delegate":
       return "object";
     case "action":
@@ -132288,7 +133134,7 @@ function referenceValue(context, member, body, dialogue) {
     }
     const symbol = context.localValues?.byValueId.get(id2)?.name ?? context.symbolsByValueId.get(id2);
     if (symbol !== void 0) return `Reference(${symbol})`;
-    const type = dialogue ? "Dialogue" : memberReferenceType(context, member);
+    const type = dialogue ? "NeoDialogue" : memberReferenceType(context, member);
     if (!dialogue) {
       const key = uniqueIndexKeyForTarget(context, member, id2);
       if (key !== null) return `Reference<${type}>(key: ${quote3(key)})`;
@@ -132647,7 +133493,7 @@ function memberDefaultBody(member) {
   if (!("value" in defaultValue)) return null;
   return defaultValue.value;
 }
-var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, MEMBER_KIND_CLASS2, LEADING_AUTHORED_ROW_ID, INITIALIZER_KEY_PLACEHOLDER, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
+var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, MEMBER_KIND_CLASS2, LEADING_AUTHORED_ROW_ID, INITIALIZER_KEY_PLACEHOLDER, MissingStoredMemberError, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
 var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
@@ -132712,6 +133558,8 @@ var init_value_sources = __esm({
       `${PENDING_ID_PREFIX}reference-key:init:\\d+`,
       "g"
     );
+    MissingStoredMemberError = class extends Error {
+    };
     CANONICAL_CONSTRUCTOR_INLINE_WIDTH = 88;
   }
 });
@@ -136537,9 +137385,11 @@ function emitDialogue(args) {
     content: `@id(${quote5(dialogueId)})
 ${args.recoveryReason ? `@incomplete(${quote5(args.recoveryReason)})
 ` : ""}@settings(
-${settings.map(([name, value]) => `  ${name}: ${value}`).join(",\n")}
+${settings.map(([name, value]) => `  ${name}: ${value}`).join(
+      ",\n"
+    )}
 )
-sealed class ${args.className} : Dialogue {
+sealed class ${args.className} : NeoDialogue {
 ${members.map((member) => indentNeoSource(member, 2)).join("\n\n")}
 }
 `,
@@ -136574,11 +137424,14 @@ function emitTrigger(context, node) {
     if (groupName && optionName && !context.groupChildNames.get(groupId)?.has(optionName))
       args.push(["group", `${groupName}.${optionName}`]);
     else if (groupId) {
-      args.push(["group", `Reference<DialogueGroup>(id: ${quote5(groupId)})`]);
+      args.push([
+        "group",
+        `Reference<NeoDialogueGroup>(id: ${quote5(groupId)})`
+      ]);
       if (optionId) {
         args.push([
           "priority",
-          `Reference<PriorityOption>(id: ${quote5(optionId)})`
+          `Reference<NeoPriorityOption>(id: ${quote5(optionId)})`
         ]);
       }
     }
@@ -137283,7 +138136,7 @@ var init_dialogue_sources = __esm({
     init_ui_action_source();
     PERSISTED_VARIABLE_PATH = /^(?:ref|linked):([^.]+)(\..+)?$/u;
     DIALOGUE_SYSTEM_TYPE_NAMES = [
-      "Dialogue",
+      "NeoDialogue",
       "Trigger",
       "Text",
       "Actions",
@@ -138478,6 +139331,7 @@ function loadOrBuildNeoScriptProjectV1(root, document) {
   const project = createNeoScriptCompilationProject({
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     enums: document.enums,
@@ -139410,6 +140264,25 @@ function workspaceStatusInitializerDiagnostic(workspace, status, sites, texts, a
   }
 }
 function computeWorkspaceStatus(workspace, options) {
+  const conflictedFiles = [];
+  const parseErrors = [];
+  const parseWarnings = [];
+  try {
+    return computeStatus(
+      workspace,
+      options,
+      conflictedFiles,
+      parseErrors,
+      parseWarnings
+    );
+  } catch (error) {
+    if (error instanceof MissingStoredMemberError && parseErrors.some(isBlockingSchemaSourceError)) {
+      return refusedStatus(conflictedFiles, parseErrors, parseWarnings);
+    }
+    throw error;
+  }
+}
+function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWarnings) {
   assertCurrentBaseline(workspace.state.records);
   let phaseStarted = performance.now();
   options.onPhase?.("Reading project schema\u2026");
@@ -139419,9 +140292,6 @@ function computeWorkspaceStatus(workspace, options) {
     phaseStarted = finished;
     if (nextLabel !== void 0) options.onPhase?.(nextLabel);
   };
-  const conflictedFiles = [];
-  const parseErrors = [];
-  const parseWarnings = [];
   const migrationSources = [];
   const projectSources = [];
   if (options.virtualSourceFiles === void 0) {
@@ -140630,6 +141500,7 @@ function replayAnimationDeclarationInitializersV4(records3, document, fallbackDo
   const compilationProject = createNeoScriptCompilationProject({
     project: replayDocument.project,
     projectFiles: replayDocument.projectFiles,
+    dialogueGroups: replayDocument.dialogueGroups,
     members: replayDocument.members,
     classes: replayDocument.classes,
     enums: replayDocument.enums,
@@ -147042,37 +147913,37 @@ function collectionSymbols(kind, type) {
   const readOnly = type.readOnly === true;
   const canMutate = !readOnly;
   const symbols = [
-    method(
+    method2(
       "Where",
       type,
       lambdaParameters(kind, entryType, keyType),
       "Filter this collection."
     ),
-    method(
+    method2(
       "First",
       entryType,
       lambdaParameters(kind, entryType, keyType),
       "Return the first matching entry; throws when none exists."
     ),
-    method(
+    method2(
       "FirstOrDefault",
       withNullability(entryType, true),
       lambdaParameters(kind, entryType, keyType),
       "Return the first matching entry, or null."
     ),
-    method(
+    method2(
       "Select",
       { kind: "list", elementType: UNKNOWN_TYPE },
       lambdaParameters(kind, entryType, keyType),
       "Map each collection entry."
     ),
-    method(
+    method2(
       "Contains",
       { kind: "primitive", name: "bool" },
       [parameter3("value", entryType)],
       "Return whether the collection contains a value."
     ),
-    method(
+    method2(
       "Count",
       { kind: "primitive", name: "int" },
       [optionalCollectionPredicate(kind, entryType, keyType)],
@@ -147120,7 +147991,7 @@ function collectionSymbols(kind, type) {
         })
       ];
     symbols.push(
-      method(
+      method2(
         name,
         returnType,
         parameters,
@@ -147130,7 +148001,7 @@ function collectionSymbols(kind, type) {
   }
   if (kind === "list") {
     symbols.push(
-      method(
+      method2(
         "IndexOf",
         { kind: "primitive", name: "int" },
         [parameter3("value", entryType)],
@@ -147220,7 +148091,7 @@ function optionalCollectionPredicate(kind, entry, key) {
     defaultValue: { displayText: "null", value: null }
   };
 }
-function method(name, returnType, parameters, documentation) {
+function method2(name, returnType, parameters, documentation) {
   return {
     id: `builtin:collection:${name}`,
     name,
@@ -147232,11 +148103,11 @@ function method(name, returnType, parameters, documentation) {
   };
 }
 function mutationMethod(name, returnType, parameters, documentation) {
-  return method(name, returnType, parameters, documentation);
+  return method2(name, returnType, parameters, documentation);
 }
 function stringReplaceSymbol() {
   const stringType = { kind: "primitive", name: "string" };
-  return method(
+  return method2(
     "Replace",
     stringType,
     [parameter3("search", stringType), parameter3("replacement", stringType)],
@@ -147244,7 +148115,7 @@ function stringReplaceSymbol() {
   );
 }
 function stringContainsSymbol() {
-  return method(
+  return method2(
     "Contains",
     { kind: "primitive", name: "bool" },
     [parameter3("substring", { kind: "primitive", name: "string" })],
@@ -147367,9 +148238,9 @@ function inferLambdaParameterType(local, snapshot) {
   ]);
   for (let cursor = declarationIndex - 1; cursor >= 1; cursor--) {
     const open = tokens[cursor];
-    const method2 = tokens[cursor - 1];
+    const method3 = tokens[cursor - 1];
     if (!open || open.kind !== "punctuation" || open.text !== "(") continue;
-    if (!method2 || method2.kind !== "identifier" || !lambdaMethods.has(method2.text)) {
+    if (!method3 || method3.kind !== "identifier" || !lambdaMethods.has(method3.text)) {
       continue;
     }
     const dot = tokens[cursor - 2];
@@ -148723,7 +149594,7 @@ function projectAnnotationNamesAt(analysis, document, position) {
       "settings",
       "storage",
       "relations",
-      .../\bDialogue\b/.test(followingDeclaration[2] ?? "") ? ["incomplete"] : []
+      .../\bNeoDialogue\b/.test(followingDeclaration[2] ?? "") ? ["incomplete"] : []
     ];
   }
   if (followingDeclaration) return ["id"];
@@ -148755,7 +149626,7 @@ function projectDeclarationAnnotationNames(declaration) {
     "settings",
     "storage",
     "relations",
-    ...declaration.baseTypes.some((type) => type.name === "Dialogue") ? ["incomplete"] : []
+    ...declaration.baseTypes.some((type) => type.name === "NeoDialogue") ? ["incomplete"] : []
   ];
 }
 function projectMemberAnnotationNames(member) {
@@ -151126,7 +151997,7 @@ function dialogueGroupCompletions(analysis, document, position) {
     items.push({
       label: name,
       kind: "variable",
-      detail: "DialogueGroup",
+      detail: "NeoDialogueGroup",
       insertText: name,
       symbolId: child2.id
     });
@@ -151136,7 +152007,7 @@ function dialogueGroupCompletions(analysis, document, position) {
     items.push({
       label: name,
       kind: "enumMember",
-      detail: "PriorityOption",
+      detail: "NeoPriorityOption",
       insertText: name,
       symbolId: option.id
     });
@@ -153042,10 +153913,10 @@ function readWorkspaceRecordFilesV4(workspace, dialogueGroupSymbols) {
   for (const absolute of listProjectSourceFilesV4(workspace.root)) {
     const path = relative4(workspace.root, absolute).split(sep4).join("/");
     const content = readFileSync11(absolute, "utf8");
-    if (dialogueGroupSymbols && /\bDialogueGroup\b/u.test(content) && neoProjectSourceKind(path, content) === "definition") {
+    if (dialogueGroupSymbols && /\bNeoDialogueGroup\b/u.test(content) && neoProjectSourceKind(path, content) === "definition") {
       const source = parseNeoProjectSource(content, "definition", path);
       for (const declaration of source.declarations) {
-        if (declaration.kind !== "global" || declaration.type.name !== "DialogueGroup")
+        if (declaration.kind !== "global" || declaration.type.name !== "NeoDialogueGroup")
           continue;
         const annotation2 = declaration.annotations.find(
           (item) => item.name === "id"
@@ -160635,11 +161506,8 @@ function dialogueGroupBaseClass(ctx, group, lookupType) {
 function dialogueGroupTriggerMethods(ctx, group, lookupType) {
   if (group.type === 0 /* Standard */) {
     return [
-      "public bool TryTrigger(out NeoDialogue dialogue) =>",
-      "    TryTriggerStandard(out dialogue);",
-      "",
-      "public bool TryTrigger(out NeoDialogueTriggerResult result) =>",
-      "    TryTriggerStandard(out result);"
+      "public bool TryTrigger(Action? onFinish = null) =>",
+      "    TryTriggerStandard(onFinish);"
     ];
   }
   if (group.type !== 1 /* Lookup */) return [];
@@ -160649,11 +161517,8 @@ function dialogueGroupTriggerMethods(ctx, group, lookupType) {
     ];
   }
   return [
-    `public bool TryTrigger(${lookupType} value, out NeoDialogue dialogue) =>`,
-    "    TryTriggerLookup(value, out dialogue);",
-    "",
-    `public bool TryTrigger(${lookupType} value, out NeoDialogueTriggerResult result) =>`,
-    "    TryTriggerLookup(value, out result);"
+    `public bool TryTrigger(${lookupType} value, Action? onFinish = null) =>`,
+    "    TryTriggerLookup(value, onFinish);"
   ];
 }
 function generateDialogueGroupProperty(ctx, group) {
@@ -160887,9 +161752,9 @@ function generateRelationTileGridContentClass(ctx, grid, saved) {
     ""
   ];
   const layerBindingExpression = (layer) => {
-    const method2 = `${saved ? "BindWritable" : "BindReadOnly"}${layer.kind === "tile" ? "Tile" : "Object"}Layer`;
+    const method3 = `${saved ? "BindWritable" : "BindReadOnly"}${layer.kind === "tile" ? "Tile" : "Object"}Layer`;
     const imports = csharpStringArray(layer.importedClassIds);
-    return `primitive.${method2}<${layer.className}>("${escapeCSharpString(layer.layerClassId)}", ${imports})`;
+    return `primitive.${method3}<${layer.className}>("${escapeCSharpString(layer.layerClassId)}", ${imports})`;
   };
   const privateConstructor = saved ? [
     `private ${className}(${primitiveType2} primitive)`,
@@ -161102,7 +161967,7 @@ function generateEnumClass(ctx, enumId) {
     ...indent([...arms, `_ => ${fallback},`]),
     "};"
   ];
-  const method2 = (signature, body) => [
+  const method3 = (signature, body) => [
     signature,
     "{",
     ...indent(body),
@@ -161127,7 +161992,7 @@ function generateEnumClass(ctx, enumId) {
     `public static class ${optionsName}`,
     "{",
     ...indent([
-      ...method2(
+      ...method3(
         `public static ${enumName} FromOptionId(string optionId)`,
         switchBody(
           "optionId",
@@ -161136,7 +162001,7 @@ function generateEnumClass(ctx, enumId) {
         )
       ),
       "",
-      ...method2(
+      ...method3(
         `public static string OptionId(this ${enumName} value)`,
         switchBody(
           "value",
@@ -161145,7 +162010,7 @@ function generateEnumClass(ctx, enumId) {
         )
       ),
       "",
-      ...method2(
+      ...method3(
         `public static string[] ToOptionIds(IEnumerable<${enumName}>? options)`,
         [
           "if (options is null) return Array.Empty<string>();",
@@ -161155,7 +162020,7 @@ function generateEnumClass(ctx, enumId) {
         ]
       ),
       "",
-      ...method2(
+      ...method3(
         "public static bool IsKnown(string optionId)",
         switchBody(
           "optionId",
@@ -161164,7 +162029,7 @@ function generateEnumClass(ctx, enumId) {
         )
       ),
       "",
-      ...method2(
+      ...method3(
         `public static string TextId(this ${enumName} value)`,
         switchBody(
           "value",
@@ -161173,7 +162038,7 @@ function generateEnumClass(ctx, enumId) {
         )
       ),
       "",
-      ...method2(
+      ...method3(
         `public static string Text(this ${enumName} value, NeoClient? client = null)`,
         [
           ctx.singleton ? `return (client ?? ${ctx.projectClassName}.RequireInstance().Client).Localization.ResolveText(value.TextId());` : "return client is null ? value.TextId() : client.Localization.ResolveText(value.TextId());"
@@ -169100,6 +169965,28 @@ function addNeoScriptFunctionReferenceDiagnostics(args) {
     });
     return;
   }
+  if (args.fn.type === "dialogueGroup" /* dialogueGroup */ || args.fn.type === "dialogue" /* dialogue */) {
+    const info = args.fn.info;
+    const pointers = [
+      ["valuePointer", "valuePointer" in info ? info.valuePointer : void 0],
+      [
+        "dialogueIdPointer",
+        "dialogueIdPointer" in info ? info.dialogueIdPointer : void 0
+      ],
+      ["onFinishPointer", info.onFinishPointer]
+    ];
+    for (const [field, pointer] of pointers) {
+      if (pointer === void 0) continue;
+      addPointerReferenceDiagnostics({
+        diagnostics: args.diagnostics,
+        pointer,
+        allowDeferredFunctions: args.allowDeferredFunctions,
+        context: args.context,
+        path: `${args.path}.info.${field}`
+      });
+    }
+    return;
+  }
   if (args.fn.type === "vectorConstructor" /* vectorConstructor */) {
     args.fn.info.componentPointers.forEach((pointer, index) => {
       addPointerReferenceDiagnostics({
@@ -170018,7 +170905,7 @@ var init_dialogue_diagnostics = __esm({
     init_interface_types();
     init_interface_graph();
     init_neoscript();
-    init_dialogue_types();
+    init_dialogue_types2();
     init_dialogue_group_types();
     init_logic_types();
     init_core();
@@ -170787,7 +171674,7 @@ var init_project_unity_export_diagnostics = __esm({
     "use strict";
     init_project_world_placement_bindings();
     init_dialogue_diagnostics();
-    init_dialogue_types();
+    init_dialogue_types2();
     init_members();
     init_core_types();
     init_inheritance();
@@ -170809,7 +171696,7 @@ var UNITY_CODEGEN_REVISION;
 var init_unity_codegen_revision = __esm({
   "../src/models/exports/unity-codegen-revision.ts"() {
     "use strict";
-    UNITY_CODEGEN_REVISION = "45a0847addd4616acfc29f142556dcb2e0a27daae14d6aa456430228e66dbc07";
+    UNITY_CODEGEN_REVISION = "e4a632a177c87244e19da71c9840b8007735773ae5f81578f58ce246ec6cb03d";
   }
 });
 
@@ -170819,7 +171706,7 @@ var init_project_unity_export_types = __esm({
   "../src/models/exports/project-unity-export-types.ts"() {
     "use strict";
     init_unity_codegen_revision();
-    PROJECT_UNITY_EXPORT_SCHEMA_VERSION = 38;
+    PROJECT_UNITY_EXPORT_SCHEMA_VERSION = 39;
   }
 });
 
@@ -175872,6 +176759,7 @@ async function buildPostPushCompileSchema(workspace, status) {
   return {
     project,
     projectFiles: [...bucket("project-file").values()],
+    dialogueGroups: [...bucket("dialogue-group").values()],
     members: [...bucket("member").values()],
     classes: [...bucket("class").values()],
     constructors: [...bucket("constructor").values()],
@@ -175885,6 +176773,7 @@ function createPostPushCompileContext(schema) {
   const project = {
     project: schema.project,
     projectFiles: schema.projectFiles,
+    dialogueGroups: schema.dialogueGroups ?? [],
     members: schema.members,
     classes: schema.classes,
     constructors: schema.constructors,
@@ -179633,6 +180522,7 @@ function createCliNeoScriptContext(options) {
   const vm = {
     project: options.documents.project,
     projectFiles: [...options.documents.projectFiles ?? []],
+    dialogueGroups: [...options.documents.dialogueGroups ?? []],
     members,
     classes: [...options.documents.classes],
     enums: [...options.documents.enums],
@@ -179659,10 +180549,25 @@ function createCliNeoScriptContext(options) {
     // root placement is server context, not authored schema-manifest state.
     roots: compilerContext.project.roots,
     globals: compilerContext.project.globals,
-    version: compilerContext.project.version
+    version: compilerContext.project.version,
+    dialogueGroups: cliDialogueGroupSources(options.documents)
   });
   return { ...compilerContext, project: projection.project };
 }
+function cliDialogueGroupSources(documents) {
+  if (!documents.dialogueGroups?.length) return [];
+  const members = new Map(
+    documents.members.map((member) => [member.id, member])
+  );
+  const classes = new Map(
+    documents.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  return storedDialogueGroupSources(
+    documents.dialogueGroups,
+    (id2) => members.get(id2),
+    (id2) => classes.get(id2)
+  );
+}
 async function validateCliNeoScript(uri, source, context) {
   const service = createCliNeoScriptLanguageService();
   const document = {
@@ -179719,7 +180624,8 @@ function createCliManifestScriptContext(manifest, scriptPath2, unit, options = {
   const projectedManifest = manifestWithUniqueInlineScriptKeys(manifest);
   const projection = projectSchemaManifest(projectedManifest, {
     ...options.rootMemberIds ? { rootMemberIds: options.rootMemberIds } : {},
-    ...options.sourceUri ? { sourceUri: options.sourceUri } : {}
+    ...options.sourceUri ? { sourceUri: options.sourceUri } : {},
+    ...options.dialogueGroups ? { dialogueGroups: options.dialogueGroups } : {}
   });
   const normalizedPath = options.memberId === void 0 ? normalizeWorkspacePath(scriptPath2) : inlineScriptKey(scriptPath2, options.memberId);
   const script = projection.scripts.get(normalizedPath);
@@ -179767,7 +180673,8 @@ function analyzeManifestScripts(manifest, options = {}) {
   const projectedManifest = manifestWithUniqueInlineScriptKeys(manifest);
   const projection = projectSchemaManifest(projectedManifest, {
     ...options.rootMemberIds ? { rootMemberIds: options.rootMemberIds } : {},
-    ...options.sourceUri ? { sourceUri: options.sourceUri } : {}
+    ...options.sourceUri ? { sourceUri: options.sourceUri } : {},
+    ...options.dialogueGroups ? { dialogueGroups: options.dialogueGroups } : {}
   });
   const sources2 = /* @__PURE__ */ new Map();
   const scriptPathByMemberId = /* @__PURE__ */ new Map();
@@ -179849,6 +180756,7 @@ var init_neoscript_language_adapter = __esm({
     init_service();
     init_strict_ir();
     init_neoscript_language_context_adapter();
+    init_dialogue_group_language();
   }
 });
 
@@ -180821,7 +181729,8 @@ async function runScript(workspace, command, options, dependencies = {}) {
         localCheckManifest,
         localTarget,
         command,
-        options
+        options,
+        localCheckDocument === null ? [] : cliDialogueGroupSources(localCheckDocument)
       );
       return;
     }
@@ -180872,6 +181781,7 @@ async function runScript(workspace, command, options, dependencies = {}) {
   const compilerProject = {
     project: document.project,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     members: document.members,
     classes: document.classes,
     constructors: document.constructors,
@@ -181044,6 +181954,7 @@ async function runScript(workspace, command, options, dependencies = {}) {
     variants: document.variants,
     variantFolders: document.variantFolders,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     textureTemplates: document.textureTemplates,
     localizationConfig: document.localizationConfig,
     localizedTexts: document.localizedTexts,
@@ -181506,7 +182417,7 @@ function localMemberOwnerKeys(member) {
   }
   return [];
 }
-async function runLocalTargetCommand(manifest, target, command, options) {
+async function runLocalTargetCommand(manifest, target, command, options, dialogueGroups) {
   const member = target.member;
   const script = member.script;
   if (script === null) {
@@ -181561,6 +182472,7 @@ async function runLocalTargetCommand(manifest, target, command, options) {
   const source = readSource(options, fallback);
   const context = createCliManifestScriptContext(manifest, script.path, unit, {
     memberId: member.id,
+    dialogueGroups,
     ...target.receiverClassId && member.modifier !== "static" ? { receiverClassId: target.receiverClassId } : {}
   });
   const diagnostics = await validateCliNeoScript(
@@ -181622,11 +182534,11 @@ async function runLocalTargetCommand(manifest, target, command, options) {
     options.json ? JSON.stringify({ ...report, ...functionMetadata }, null, 2) : "Compiles cleanly."
   );
 }
-function collectLocalCheckAll(manifest, options) {
+function collectLocalCheckAll(manifest, options, dialogueGroups) {
   const membersById = new Map(
     manifest.members.filter(isLocalScriptMember).map((member) => [member.id, member])
   );
-  const analyses = analyzeManifestScripts(manifest);
+  const analyses = analyzeManifestScripts(manifest, { dialogueGroups });
   const results = analyses.map((analysis) => {
     const member = membersById.get(analysis.memberId);
     if (member === void 0) {
@@ -181664,7 +182576,11 @@ function localScriptUri(path) {
   return `neo-script:///${normalizeScriptPath(path).split("/").map((part) => encodeURIComponent(part)).join("/")}`;
 }
 function runCheckAll(document, manifest, options) {
-  const local = collectLocalCheckAll(manifest, options);
+  const local = collectLocalCheckAll(
+    manifest,
+    options,
+    cliDialogueGroupSources(document)
+  );
   let failures = local.failures;
   let checked = local.checked;
   const results = [...local.results];
@@ -181757,7 +182673,7 @@ var init_script = __esm({
     init_save_overlay_resolution();
     init_members();
     init_neoscript();
-    init_dialogue_types();
+    init_dialogue_types2();
     init_logic_types();
     init_dialogue_logic_compile_pure();
     init_project_migration_runner();
@@ -181965,6 +182881,7 @@ function sharedEvaluatorBase(rawDocument) {
     variants: document.variants,
     variantFolders: document.variantFolders,
     projectFiles: document.projectFiles,
+    dialogueGroups: document.dialogueGroups,
     textureTemplates: document.textureTemplates,
     localizationConfig: document.localizationConfig,
     localizedTexts: document.localizedTexts,
@@ -185093,6 +186010,7 @@ async function runPendingMigrations(workspace, fetched, migrations, onlyRef) {
       () => compileNSVoidBody(migrationCode, {
         project: document.project,
         projectFiles: document.projectFiles,
+        dialogueGroups: document.dialogueGroups,
         members: document.members,
         classes: document.classes,
         constructors: document.constructors,
@@ -185137,6 +186055,7 @@ async function runPendingMigrations(workspace, fetched, migrations, onlyRef) {
               classes: document.classes,
               enums: document.enums,
               projectFiles: document.projectFiles,
+              dialogueGroups: document.dialogueGroups,
               localizationConfig: document.localizationConfig,
               localizedTexts: document.localizedTexts,
               ...runtime
@@ -186913,7 +187832,7 @@ var init_dialogue_lookup_candidates = __esm({
 var init_dialogue_record_split = __esm({
   "../src/models/dialogue/dialogue-record-split.ts"() {
     "use strict";
-    init_dialogue_types();
+    init_dialogue_types2();
   }
 });
 
@@ -186923,7 +187842,7 @@ var init_dialogue_localized_text_links = __esm({
     "use strict";
     init_localized_text_create_envelope();
     init_localization_types();
-    init_dialogue_types();
+    init_dialogue_types2();
   }
 });
 
@@ -186958,7 +187877,7 @@ var init_dialogue_triggering = __esm({
 var init_dialogue = __esm({
   "../src/models/dialogue/index.ts"() {
     "use strict";
-    init_dialogue_types();
+    init_dialogue_types2();
     init_dialogue_source_identifiers();
     init_dialogue_source_names();
     init_dialogue_lookup_candidates();
@@ -188923,6 +189842,7 @@ function buildWorld(document, raw) {
       variants: document.variants,
       variantFolders: document.variantFolders,
       projectFiles: document.projectFiles,
+      dialogueGroups: document.dialogueGroups,
       localizationConfig: document.localizationConfig,
       localizedTexts: document.localizedTexts,
       ...runtime
@@ -190519,7 +191439,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.72.4");
+    console.log("0.73.1");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {