@neocompose/cli 0.72.2 → 0.73.0

package/dist/test-worker.mjs

@@ -1561,6 +1561,260 @@ function isGeneratedCSharpReservedKeyword(value) {
 function generatedCSharpMemberNameForSchemaKey(schemaKey) {
   return isGeneratedCSharpReservedKeyword(schemaKey) ? `${schemaKey}Value` : schemaKey;
 }
+function generatedCSharpTypeName(value, fallback) {
+  const parts = value.match(/[A-Za-z0-9]+/g) ?? [];
+  const joined = parts.map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join("");
+  const candidate = joined.length > 0 ? joined : fallback;
+  const safe = /^[0-9]/.test(candidate) ? `_${candidate}` : candidate;
+  return isGeneratedCSharpReservedKeyword(safe) ? `${safe}Type` : safe;
+}
+function generatedCSharpShortId(id) {
+  return id.replace(/[^A-Za-z0-9_]/g, "").slice(0, 8) || "Id";
+}
+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;
+}
+
+// ../packages/neoscript-language/src/dialogue-types.ts
+var NEOSCRIPT_DIALOGUES_MEMBER_NAME = "Dialogues";
+var NEOSCRIPT_DIALOGUES_TYPE_ID = "builtin:Dialogues";
+var 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" }]
+]);
+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}\`.`;
+}
+var BOOL_TYPE = { kind: "primitive", name: "bool" };
+var INT_TYPE = { kind: "primitive", name: "int" };
+var STRING_TYPE = { kind: "primitive", name: "string" };
+var NEOSCRIPT_DIALOGUE_ON_FINISH_TYPE = {
+  kind: "delegate",
+  returnType: { kind: "primitive", name: "void" },
+  parameterTypes: [],
+  nullable: true
+};
+var 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."
+};
+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."
+    )
+  ];
+}
+var KIND_LABELS = {
+  standard: "Dialogue group",
+  lookup: "Lookup dialogue group",
+  folder: "Dialogue folder"
+};
+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
+  };
+}
 
 // ../packages/neoscript-language/src/language-spec.ts
 var NEOSCRIPT_KEYWORDS = [
@@ -1620,7 +1874,7 @@ var NEOSCRIPT_BUILTIN_ANNOTATION_TYPES = [
   "FunctionRef",
   "NeoDelegate",
   "NeoAction",
-  "Dialogue",
+  "NeoDialogue",
   "Trigger",
   "Node",
   "Text",
@@ -1630,7 +1884,7 @@ var NEOSCRIPT_BUILTIN_ANNOTATION_TYPES = [
   "Outcome",
   "SpriteInfo",
   "AudioClipInfo",
-  "DialogueRef",
+  "NeoDialogueReference",
   "Vector2",
   "Vector2Int",
   "Vector3",
@@ -1677,10 +1931,10 @@ var NEOSCRIPT_OPERATORS = [
   "<",
   ">"
 ];
-var STRING_TYPE = { kind: "primitive", name: "string" };
-var INT_TYPE = { kind: "primitive", name: "int" };
+var STRING_TYPE2 = { kind: "primitive", name: "string" };
+var INT_TYPE2 = { kind: "primitive", name: "int" };
 var FLOAT_TYPE = { kind: "primitive", name: "float" };
-var BOOL_TYPE = { kind: "primitive", name: "bool" };
+var BOOL_TYPE2 = { kind: "primitive", name: "bool" };
 var IMAGE_REF_TYPE = {
   kind: "primitive",
   name: "ImageRef"
@@ -1705,7 +1959,7 @@ var NEOSCRIPT_STRUCTURED_LEAF_FIELDS = {
     {
       name: "SliceIndex",
       key: "sliceIndex",
-      type: INT_TYPE,
+      type: INT_TYPE2,
       documentation: "Index into the file's slices."
     }
   ],
@@ -1727,13 +1981,13 @@ var NEOSCRIPT_STRUCTURED_LEAF_FIELDS = {
     {
       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."
     }
   ],
@@ -1761,19 +2015,19 @@ var NEOSCRIPT_STRUCTURED_LEAF_FIELDS = {
     {
       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."
     }
   ],
@@ -1856,14 +2110,14 @@ function builtinFunction(name, returnType, parameters, documentation) {
 var 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."
   )
 ];
@@ -1931,8 +2185,8 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
       // `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",
@@ -1962,8 +2216,8 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
     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",
@@ -1973,10 +2227,13 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
     ]
   },
   {
-    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(),
   {
@@ -1998,7 +2255,7 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
       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."
@@ -2029,25 +2286,25 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
         "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",
@@ -2058,7 +2315,7 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
         "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",
@@ -2099,7 +2356,7 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
         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
@@ -2187,6 +2444,11 @@ function relativeDebugUri(uri) {
 
 // ../packages/neoscript-language/src/strict-ir.ts
 var NEOSCRIPT_COMPILER_REVISION = 17;
+var NeoScriptDialogueOp = /* @__PURE__ */ ((NeoScriptDialogueOp2) => {
+  NeoScriptDialogueOp2["TryTrigger"] = "TryTrigger";
+  NeoScriptDialogueOp2["CanTrigger"] = "CanTrigger";
+  return NeoScriptDialogueOp2;
+})(NeoScriptDialogueOp || {});
 
 // ../src/models/neoscript/neoscript-compiler-revision.ts
 var ACTIVE_NEOSCRIPT_COMPILER_REVISION_ROLLOUT = (
@@ -3074,6 +3336,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 */;
 }
@@ -3133,7 +3420,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;
@@ -22268,6 +22555,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,
@@ -33780,14 +34087,17 @@ var Scope = class {
     return this.invalidatedRoots;
   }
   effectiveNarrowedPaths() {
-    const effective = this.parent ? new Map(this.parent.effectiveNarrowedPaths()) : /* @__PURE__ */ new Map();
-    for (const invalidated of this.invalidatedRoots) {
-      for (const [path, narrowed] of effective) {
-        if (narrowed.rootEntry === invalidated) effective.delete(path);
+    const effective = new Map(this.narrowedPaths);
+    const invalidated = new Set(this.invalidatedRoots);
+    for (const root of this.hiddenNarrowingRoots) invalidated.add(root);
+    for (let current = this.parent; current; current = current.parent) {
+      for (const [path, narrowed] of current.narrowedPaths) {
+        if (!effective.has(path) && !invalidated.has(narrowed.rootEntry)) {
+          effective.set(path, narrowed);
+        }
       }
-    }
-    for (const [path, narrowed] of this.narrowedPaths) {
-      effective.set(path, narrowed);
+      for (const root of current.invalidatedRoots) invalidated.add(root);
+      for (const root of current.hiddenNarrowingRoots) invalidated.add(root);
     }
     return effective;
   }
@@ -33813,6 +34123,9 @@ var Scope = class {
   hideInheritedNarrowing(rootEntry) {
     this.hiddenNarrowingRoots.add(rootEntry);
     this.updatePatternType(rootEntry, rootEntry.type);
+    for (const [path, narrowed] of this.narrowedPaths) {
+      if (narrowed.rootEntry === rootEntry) this.narrowedPaths.delete(path);
+    }
   }
   invalidate(rootEntry) {
     this.invalidatedRoots.add(rootEntry);
@@ -34370,24 +34683,26 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const branchExitNarrowings = [];
         const branchExitOwnershipScopes = [];
         const branches = statement.branches.map((branch) => {
+          const conditionScope = new Scope(scope);
+          this.applyFactsToScope(conditionScope, cumulativeFalseFacts);
           const condition = this.toBool(
-            this.resolveExpression(branch.cond, scope),
+            this.resolveExpression(branch.cond, conditionScope),
             branch.cond.pos
           );
           const child = new Scope(scope);
           const branchFacts = [
             ...cumulativeFalseFacts,
-            ...this.conditionFacts(branch.cond, scope, true)
+            ...this.conditionFacts(branch.cond, conditionScope, true)
           ];
           this.applyFactsToScope(child, branchFacts);
           const instructions = this.resolveStatements(branch.body, child);
           if (!instructionsTerminate(instructions)) {
             branchExitFacts.push(branchFacts);
-            branchExitNarrowings.push(new Map(child.narrowedPaths));
+            branchExitNarrowings.push(child.effectiveNarrowedPaths());
             branchExitOwnershipScopes.push(child);
           }
           cumulativeFalseFacts.push(
-            ...this.conditionFacts(branch.cond, scope, false)
+            ...this.conditionFacts(branch.cond, conditionScope, false)
           );
           return {
             expression: pointerToBooleanExpression(condition.pointer),
@@ -34401,14 +34716,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           otherwise = this.resolveStatements(statement.elseBody, elseScope);
           if (!instructionsTerminate(otherwise)) {
             branchExitFacts.push([...cumulativeFalseFacts]);
-            branchExitNarrowings.push(new Map(elseScope.narrowedPaths));
+            branchExitNarrowings.push(elseScope.effectiveNarrowedPaths());
             branchExitOwnershipScopes.push(elseScope);
           }
         } else {
           const noBranchScope = new Scope(scope);
           this.applyFactsToScope(noBranchScope, cumulativeFalseFacts);
           branchExitFacts.push([...cumulativeFalseFacts]);
-          branchExitNarrowings.push(new Map(noBranchScope.narrowedPaths));
+          branchExitNarrowings.push(noBranchScope.effectiveNarrowedPaths());
           branchExitOwnershipScopes.push(noBranchScope);
         }
         mergeBranchInvalidations(scope, branchExitOwnershipScopes);
@@ -34642,12 +34957,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           statement.body,
           conditionLocals
         );
-        this.invalidateLoopEntryNarrowingsAssignedBy(
-          loopEntryScope,
-          loopScope,
-          [statement.iterator],
-          conditionLocals
-        );
+        const bodyFlow = statementFlow(statement.body, /* @__PURE__ */ new WeakMap());
+        if (bodyFlow.has("fallthrough") || bodyFlow.has("continue")) {
+          this.invalidateLoopEntryNarrowingsAssignedBy(
+            loopEntryScope,
+            loopScope,
+            [statement.iterator],
+            conditionLocals
+          );
+        }
         const condition = this.toBool(
           this.resolveExpression(statement.condition, loopEntryScope),
           statement.condition.pos
@@ -35084,23 +35402,23 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   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 method = expr.callee.name;
+    const method2 = expr.callee.name;
     const severities = {
       Log: "log",
       LogWarning: "warning",
       LogError: "error",
       Assert: "assert"
     };
-    if (!Object.hasOwn(severities, method))
-      throw new CompileError(`Unknown Debug method '${method}'.`, expr.pos);
-    const severity = severities[method];
-    const expected = method === "Assert" ? 2 : 1;
+    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 (expr.args.length !== expected)
       throw new CompileError(
-        `Debug.${method} expects ${expected} argument(s).`,
+        `Debug.${method2} expects ${expected} argument(s).`,
         expr.pos
       );
-    const condition = method === "Assert" ? this.resolveExpression(requiredAt(expr.args, 0), scope) : void 0;
+    const condition = method2 === "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.",
@@ -35514,13 +35832,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (assignedPath) {
       const rootEntry = scope.lookup(pathRoot(assignedPath));
       if (rootEntry) {
-        const receiverFacts = receiverNarrowings(
+        const retainedFacts = unaffectedNarrowings(
           assignedPath,
           rootEntry,
           scope
         );
         scope.invalidate(rootEntry);
-        for (const [path, type] of receiverFacts) {
+        for (const [path, type] of retainedFacts) {
           scope.narrow(path, rootEntry, type);
         }
         if (statement.op === "=" && !isNullable(value.type)) {
@@ -35737,13 +36055,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (assignedPath) {
       const rootEntry = scope.lookup(pathRoot(assignedPath));
       if (rootEntry) {
-        const receiverFacts = receiverNarrowings(
+        const retainedFacts = unaffectedNarrowings(
           assignedPath,
           rootEntry,
           scope
         );
         scope.invalidate(rootEntry);
-        for (const [path, type] of receiverFacts) {
+        for (const [path, type] of retainedFacts) {
           scope.narrow(path, rootEntry, type);
         }
       }
@@ -35990,6 +36308,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
   }
   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 = {
@@ -36358,18 +36687,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       case "coalesce": {
         const left = this.resolveExpression(expression.left, scope);
         const leftOptional = { ...left.type, nullable: true };
+        const nullLeft = isNull(left.type);
         const right = this.resolveExpression(
           expression.right,
           scope,
-          leftOptional
+          nullLeft ? expected : leftOptional
         );
-        if (!isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
+        if (!nullLeft && !isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
           throw new CompileError(
             `\`??\` right operand ${this.describe(right.type)} is not assignable to ${this.describe(leftOptional)}`,
             expression.pos
           );
         }
-        const resultType = {
+        const resultType = nullLeft ? right.type : {
           ...left.type,
           nullable: isNullable(left.type) && isNullable(right.type)
         };
@@ -37070,20 +37400,25 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return whenTrue ? factsWhenTrue(expression, pathOf) : factsWhenFalse(expression, pathOf);
   }
   /**
-   * A loop body is resolved once but can execute repeatedly. Any narrowing rooted
-   * in an outer binding that the body or iterator may write is therefore stale
-   * at a later iteration entry. Invalidate those roots before resolving the
-   * shared iteration so only the loop's own condition can narrow them again.
+   * A loop body is resolved once but can execute repeatedly. Hide facts about
+   * paths it may replace before resolving the shared iteration; unrelated facts
+   * still hold, and the loop condition can narrow the written paths again.
    */
   invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements, locals = /* @__PURE__ */ new Set()) {
-    for (const rootName of collectAssignedPathRoots(
+    for (const assignedPath of collectAssignedPaths(
       statements,
       /* @__PURE__ */ new Set(),
       locals
     )) {
-      const path = this.narrowingPath(rootName, outerScope);
+      const path = this.narrowingPath(assignedPath, outerScope);
       const outerEntry = path === null ? null : outerScope.lookup(pathRoot(path));
-      if (outerEntry) loopEntryScope.hideInheritedNarrowing(outerEntry);
+      if (outerEntry && path !== null) {
+        const retained = unaffectedNarrowings(path, outerEntry, loopEntryScope);
+        loopEntryScope.hideInheritedNarrowing(outerEntry);
+        for (const [retainedPath, type] of retained) {
+          loopEntryScope.narrow(retainedPath, outerEntry, type);
+        }
+      }
     }
   }
   applyFactsToScope(targetScope, facts, mode = "all") {
@@ -37561,7 +37896,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         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)}`,
@@ -37657,7 +37992,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     const primitiveMember = resolvePrimitiveMember(receiver.type, name);
     if (primitiveMember) {
-      if (isPrimitive(receiver.type, "DialogueRef")) {
+      if (isPrimitive(receiver.type, "NeoDialogueReference")) {
         return {
           pointer: {
             type: "keyOf" /* KeyOf */,
@@ -37690,12 +38025,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         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);
@@ -37724,6 +38062,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       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.`,
@@ -38078,6 +38420,227 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
   }
+  /** 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.
@@ -38283,7 +38846,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return () => {
       if (!result) {
         try {
-          result = { value: this.resolveExpression(callee.receiver, scope) };
+          result = {
+            value: this.resolveReceiverExpression(callee.receiver, scope)
+          };
         } catch (error) {
           result = { error };
         }
@@ -38338,31 +38903,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       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(
@@ -38467,12 +39012,37 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     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);
     }
@@ -40754,6 +41324,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
     }
     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);
@@ -41503,12 +42074,18 @@ function identPathSegments(expression) {
   if (receiver === null) return null;
   return [...receiver, expression.name];
 }
-function receiverNarrowings(path, rootEntry, scope) {
+function unaffectedNarrowings(path, rootEntry, scope) {
   const facts = [];
-  for (let dot = path.indexOf("."); dot !== -1; dot = path.indexOf(".", dot + 1)) {
-    const prefix = path.slice(0, dot);
-    const type = scope.lookupNarrowedType(prefix, rootEntry);
-    if (type !== null) facts.push([prefix, type]);
+  const prefix = `${path}.`;
+  const dot = path.lastIndexOf(".");
+  if (dot === -1) return facts;
+  const member = path.slice(dot);
+  for (const [candidate, narrowed] of scope.effectiveNarrowedPaths()) {
+    if (narrowed.rootEntry !== rootEntry) continue;
+    if (candidate === path || candidate.startsWith(prefix)) continue;
+    if (candidate.endsWith(member) || candidate.includes(`${member}.`))
+      continue;
+    facts.push([candidate, narrowed.type]);
   }
   return facts;
 }
@@ -41832,22 +42409,22 @@ function localsWithBindings(locals, expression, whenTrue) {
     ...facts.flatMap((fact) => fact.bindingName ? [fact.bindingName] : [])
   ]);
 }
-function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(), inheritedLocals = /* @__PURE__ */ new Set(), flowCache = /* @__PURE__ */ new WeakMap()) {
+function collectAssignedPaths(statements, roots = /* @__PURE__ */ new Set(), inheritedLocals = /* @__PURE__ */ new Set(), flowCache = /* @__PURE__ */ new WeakMap()) {
   const locals = new Set(inheritedLocals);
   for (const statement of statements) {
     if (statement.kind === "assign") {
       const assignedPath = canonicalPath(statement.target);
       if (assignedPath && !locals.has(pathRoot(assignedPath))) {
-        roots.add(pathRoot(assignedPath));
+        roots.add(assignedPath);
       }
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.target,
         roots,
         locals,
         flowCache
       );
       if (statement.value)
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           statement.value,
           roots,
           locals,
@@ -41856,7 +42433,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "varDecl") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.init,
         roots,
         locals,
@@ -41870,7 +42447,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       const falseFacts = [];
       const fallthroughFacts = [];
       for (const branch of statement.branches) {
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           branch.cond,
           roots,
           falseLocals,
@@ -41880,7 +42457,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
           ...falseFacts,
           ...factsWhenTrue(branch.cond, canonicalPath)
         ];
-        collectAssignedPathRoots(
+        collectAssignedPaths(
           branch.body,
           roots,
           localsWithBindings(falseLocals, branch.cond, true),
@@ -41892,12 +42469,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
         falseLocals = localsWithBindings(falseLocals, branch.cond, false);
       }
       if (statement.elseBody) {
-        collectAssignedPathRoots(
-          statement.elseBody,
-          roots,
-          falseLocals,
-          flowCache
-        );
+        collectAssignedPaths(statement.elseBody, roots, falseLocals, flowCache);
         if (statementFlow(statement.elseBody, flowCache).has("fallthrough"))
           fallthroughFacts.push(falseFacts);
       } else {
@@ -41909,18 +42481,18 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "try") {
-      collectAssignedPathRoots(statement.body, roots, locals, flowCache);
+      collectAssignedPaths(statement.body, roots, locals, flowCache);
       for (const clause of statement.catches) {
         const catchLocals = /* @__PURE__ */ new Set([...locals, clause.name]);
         if (clause.filter) {
-          collectAssignedPathRootsInExpression(
+          collectAssignedPathsInExpression(
             clause.filter,
             roots,
             catchLocals,
             flowCache
           );
         }
-        collectAssignedPathRoots(
+        collectAssignedPaths(
           clause.body,
           roots,
           clause.filter ? localsWithBindings(catchLocals, clause.filter, true) : catchLocals,
@@ -41930,13 +42502,13 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "while" || statement.kind === "doWhile") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.condition,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         statement.body,
         roots,
         statement.kind === "while" ? localsWithBindings(locals, statement.condition, true) : locals,
@@ -41945,14 +42517,14 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "for") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.initializer.init,
         roots,
         locals,
         flowCache
       );
       const loopLocals = /* @__PURE__ */ new Set([...locals, statement.initializer.name]);
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.condition,
         roots,
         loopLocals,
@@ -41963,22 +42535,17 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
         statement.condition,
         true
       );
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         [statement.iterator],
         roots,
         iterationLocals,
         flowCache
       );
-      collectAssignedPathRoots(
-        statement.body,
-        roots,
-        iterationLocals,
-        flowCache
-      );
+      collectAssignedPaths(statement.body, roots, iterationLocals, flowCache);
       continue;
     }
     if (statement.kind === "forEach") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.collection,
         roots,
         locals,
@@ -41986,11 +42553,11 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       );
       const loopLocals = /* @__PURE__ */ new Set([...locals, statement.name]);
       if (statement.key) loopLocals.add(statement.key.name);
-      collectAssignedPathRoots(statement.body, roots, loopLocals, flowCache);
+      collectAssignedPaths(statement.body, roots, loopLocals, flowCache);
       continue;
     }
     if (statement.kind === "switch") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.selector,
         roots,
         locals,
@@ -41999,7 +42566,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       for (const section of statement.sections) {
         for (const label of section.labels) {
           if (label.kind === "case") {
-            collectAssignedPathRootsInExpression(
+            collectAssignedPathsInExpression(
               label.expression,
               roots,
               locals,
@@ -42007,13 +42574,13 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
             );
           }
         }
-        collectAssignedPathRoots(section.body, roots, locals, flowCache);
+        collectAssignedPaths(section.body, roots, locals, flowCache);
       }
       continue;
     }
     if (statement.kind === "return" || statement.kind === "throw") {
       if (statement.expr)
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           statement.expr,
           roots,
           locals,
@@ -42022,7 +42589,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "exprStmt") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.expr,
         roots,
         locals,
@@ -42032,43 +42599,28 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
   }
   return roots;
 }
-function collectAssignedPathRootsInExpression(expression, roots, locals, flowCache) {
+function collectAssignedPathsInExpression(expression, roots, locals, flowCache) {
   switch (expression.kind) {
     case "litInterp":
       for (const part of expression.parts) {
         if (part.kind === "expr") {
-          collectAssignedPathRootsInExpression(
-            part.expr,
-            roots,
-            locals,
-            flowCache
-          );
+          collectAssignedPathsInExpression(part.expr, roots, locals, flowCache);
         }
       }
       return;
     case "litList":
       for (const element of expression.elements) {
-        collectAssignedPathRootsInExpression(element, roots, locals, flowCache);
+        collectAssignedPathsInExpression(element, roots, locals, flowCache);
       }
       return;
     case "litDict":
       for (const entry of expression.entries) {
-        collectAssignedPathRootsInExpression(
-          entry.key,
-          roots,
-          locals,
-          flowCache
-        );
-        collectAssignedPathRootsInExpression(
-          entry.value,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(entry.key, roots, locals, flowCache);
+        collectAssignedPathsInExpression(entry.value, roots, locals, flowCache);
       }
       return;
     case "member":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.receiver,
         roots,
         locals,
@@ -42076,13 +42628,13 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "index":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.receiver,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.index,
         roots,
         locals,
@@ -42090,32 +42642,22 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "call":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.callee,
         roots,
         locals,
         flowCache
       );
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(
-          argument2,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
       }
       return;
     case "new":
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(
-          argument2,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
       }
       for (const initializer of expression.initializer ?? []) {
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           initializer.value,
           roots,
           locals,
@@ -42126,15 +42668,10 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
     case "annotated":
       for (const annotation2 of expression.annotations) {
         for (const argument2 of annotation2.args) {
-          collectAssignedPathRootsInExpression(
-            argument2,
-            roots,
-            locals,
-            flowCache
-          );
+          collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
         }
       }
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.expression,
         roots,
         locals,
@@ -42143,13 +42680,13 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "binary":
     case "coalesce":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.left,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.right,
         roots,
         locals,
@@ -42157,19 +42694,19 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "conditional":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.condition,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.whenTrue,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.whenFalse,
         roots,
         locals,
@@ -42178,7 +42715,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "unary":
     case "force":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -42186,7 +42723,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "is":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -42194,7 +42731,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "lambda":
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         expression.body,
         roots,
         /* @__PURE__ */ new Set([
@@ -42260,6 +42797,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, required, acceptsOnFinish, pos) {
+  if (!acceptsOnFinish) {
+    requireArgCount(name, args, required, pos);
+    return;
+  }
+  if (args.length === required || args.length === required + 1) return;
+  throw new CompileError(
+    `${name} expects ${required} or ${required + 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: {
@@ -42466,7 +43040,7 @@ function primitiveValueKind(name) {
       return 11 /* Sprite */;
     case "AudioClipInfo":
       return 12 /* Audio */;
-    case "DialogueRef":
+    case "NeoDialogueReference":
       return 18 /* DialogueLookup */;
     case "Vector2":
       return 14 /* Vector2 */;
@@ -42499,7 +43073,7 @@ function valueKindPrimitive(kind) {
     case 12 /* Audio */:
       return "AudioClipInfo";
     case 18 /* DialogueLookup */:
-      return "DialogueRef";
+      return "NeoDialogueReference";
     case 14 /* Vector2 */:
       return "Vector2";
     case 15 /* Vector2Int */:
@@ -42690,7 +43264,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;
 }
@@ -42789,7 +43363,7 @@ function namedPrimitive(name) {
     case "decimal":
     case "SpriteInfo":
     case "AudioClipInfo":
-    case "DialogueRef":
+    case "NeoDialogueReference":
     case "Vector2":
     case "Vector2Int":
     case "Vector3":
@@ -43024,7 +43598,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,
@@ -43365,7 +43942,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 ?? [
     {
@@ -43384,7 +43962,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(
@@ -43519,7 +44097,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"],
@@ -43542,6 +44120,7 @@ function createRootType(ids, environment) {
       ...sourceLocation(member.source, environment, `root.${name}.source`)
     });
   }
+  members.push(dialogues);
   return {
     id: "__root__",
     name: "Root",
@@ -44318,8 +44897,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 manifestType(member.returnType, environment, `${field}.returnType`);
@@ -44801,7 +45379,7 @@ function manifestPrimitive(kind) {
     case "vector3Int":
       return "Vector3Int";
     case "dialogueLookup":
-      return "DialogueRef";
+      return "NeoDialogueReference";
     case "color":
       return "Color";
     default:
@@ -45197,6 +45775,164 @@ function pascalIdentifier(value) {
   return identifier;
 }
 
+// ../src/models/dialogue/dialogue-source-identifiers.ts
+function isDialogueSourceIdentifier(value) {
+  return isValidProjectSourceIdentifier(value);
+}
+
+// ../src/models/dialogue/logic-types.ts
+function isNSBoolGetter(value) {
+  if (!isNSGetter(value)) return false;
+  if (value.typeInfo.type !== 1 /* Bool */) return false;
+  return value.typeInfo.required === true;
+}
+function isNSVoidBody2(value) {
+  if (!isNSGetter(value)) return false;
+  if (value.typeInfo.type !== 0 /* Null */) return false;
+  return value.typeInfo.required === true;
+}
+function isUILogicCondition(value) {
+  const v = value;
+  if (typeof v !== "object") return false;
+  if (v === null) return false;
+  if (!isNonEmptyString(v.id)) return false;
+  if (v.type !== 0 /* UI */) return false;
+  if (!isNSBoolGetter(v.getter)) return false;
+  return isUIRenderableCondition(v.getter);
+}
+function isCodeLogicCondition(value) {
+  const v = value;
+  if (typeof v !== "object") return false;
+  if (v === null) return false;
+  if (!isNonEmptyString(v.id)) return false;
+  if (v.type !== 1 /* Code */) return false;
+  if (!isNonEmptyString(v.sourceFunctionId)) return false;
+  if (!isDialogueSourceIdentifier(v.sourceFunctionName)) return false;
+  if (typeof v.code !== "string") return false;
+  return isNSBoolGetter(v.getter);
+}
+function isLogicCondition(value) {
+  return isUILogicCondition(value) || isCodeLogicCondition(value);
+}
+function isUILogicAction(value) {
+  const v = value;
+  if (typeof v !== "object") return false;
+  if (v === null) return false;
+  if (v.type !== 0 /* UI */) return false;
+  if (!isNSVoidBody2(v.action)) return false;
+  return isUIRenderableAction(v.action);
+}
+function isCodeLogicAction(value) {
+  const v = value;
+  if (typeof v !== "object") return false;
+  if (v === null) return false;
+  if (v.type !== 1 /* Code */) return false;
+  if (!isNonEmptyString(v.sourceFunctionId)) return false;
+  if (!isDialogueSourceIdentifier(v.sourceFunctionName)) return false;
+  if (typeof v.code !== "string") return false;
+  return isNSVoidBody2(v.action);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isLogicAction(value) {
+  return isUILogicAction(value) || isCodeLogicAction(value);
+}
+function isUIRenderableCondition(getter) {
+  if (getter.instructions.length !== 1) return false;
+  return getter.instructions[0]?.type === "return" /* return */;
+}
+function isUIRenderableAction(action) {
+  if (action.instructions.length === 0) return true;
+  if (action.instructions.length !== 1) return false;
+  const instruction = action.instructions[0];
+  if (!instruction) return false;
+  return instruction.type === "return" /* return */ || instruction.type === "assign" /* assign */ || instruction.type === "collectionCall" /* collectionCall */ || instruction.type === "functionCall" /* functionCall */;
+}
+
+// ../src/models/dialogue/dialogue-group-types.ts
+function isOptionalNullableString2(value) {
+  if (value === void 0) return true;
+  if (value === null) return true;
+  return typeof value === "string";
+}
+function isDialogueGroupType(value) {
+  return value === 0 /* Standard */ || value === 1 /* Lookup */ || value === 2 /* Folder */;
+}
+function isDialogueGroupBase(value, expectedType) {
+  const v = value;
+  if (typeof v !== "object") return false;
+  if (v === null) return false;
+  if (typeof v.name !== "string") return false;
+  if (!isDialogueGroupType(v.type)) return false;
+  if (expectedType !== void 0 && v.type !== expectedType) return false;
+  if (!isOptionalNullableString2(v.parentDialogueGroupId)) return false;
+  if (!Array.isArray(v.conditions)) return false;
+  if (!v.conditions.every(isLogicCondition)) return false;
+  return isOptionalNullableString2(v.priorityGroupIdOverride);
+}
+function isStandardDialogueGroupBase(value) {
+  return isDialogueGroupBase(value, 0 /* Standard */);
+}
+function isLookupDialogueGroupBase(value) {
+  const v = value;
+  if (!isDialogueGroupBase(value, 1 /* Lookup */)) return false;
+  if (typeof v?.collectionMemberId !== "string") return false;
+  return isOptionalNullableString2(v.collectionValueId);
+}
+function isFolderDialogueGroupBase(value) {
+  return isDialogueGroupBase(value, 2 /* Folder */);
+}
+function isDialogueGroupProps(value, expectedType) {
+  const v = value;
+  if (!isDialogueGroupBase(value, expectedType)) return false;
+  if (!isWithId(value)) return false;
+  if (!isIWithTimestamps(value)) return false;
+  return typeof v?.projectId === "string";
+}
+function isDialogueGroup(value, expectedType) {
+  return isDialogueGroupProps(value, expectedType);
+}
+function isAnyDialogueGroup(value) {
+  if (!isDialogueGroup(value)) return false;
+  return isStandardDialogueGroupBase(value) || isLookupDialogueGroupBase(value) || isFolderDialogueGroupBase(value);
+}
+
+// ../src/models/dialogue/dialogue-group-language.ts
+var KINDS = {
+  [0 /* Standard */]: "standard",
+  [1 /* Lookup */]: "lookup",
+  [2 /* Folder */]: "folder"
+};
+function storedDialogueGroupSources(groups, memberById, classById) {
+  const sources2 = [];
+  for (const group of groups) {
+    const lookup = group.type === 1 /* Lookup */ ? lookupEntry(group.collectionMemberId, memberById, 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, memberById, classById) {
+  const collection = memberById(collectionMemberId);
+  if (!isMemberListBase(collection) && !isMemberDictionaryBase(collection))
+    return void 0;
+  const entry = memberById(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
+  };
+}
+
 // ../src/runtime/neoscript/analyzer-types.ts
 var AnalyzerRootClassId = "__root__";
 var AnalyzerDialogueContextClassId = "__dialogue_context__";
@@ -45238,7 +45974,7 @@ function resolveAnalyzerMember(context, member) {
 }
 
 // ../src/runtime/neoscript/neoscript-language-context-adapter.ts
-var NEOSCRIPT_COMPILER_ADAPTER_REVISION = 5;
+var NEOSCRIPT_COMPILER_ADAPTER_REVISION = 6;
 var UNKNOWN_TYPE = {
   kind: "primitive",
   name: "unknown"
@@ -45415,8 +46151,15 @@ function createNeoScriptProjectInScope(context) {
       })
     });
   }
-  const rootType = createRootType2(context);
-  languageTypes.push(rootType);
+  const dialogues = neoScriptDialogueTypes(
+    storedDialogueGroupSources(
+      context.vm.dialogueGroups ?? [],
+      (id) => analyzerMemberById(context, id),
+      (id) => analyzerSchemaIndex(context).classesById.get(id)
+    )
+  );
+  const rootType = createRootType2(context, dialogues.member);
+  languageTypes.push(rootType, ...dialogues.types);
   if (context.dialogueContext) {
     languageTypes.push(createDialogueContextType(context));
   }
@@ -45951,7 +46694,7 @@ var ROOT_WRITABILITY = {
   [3 /* Session */]: "session",
   [5 /* User */]: "user"
 };
-function createRootType2(context) {
+function createRootType2(context, dialogues) {
   const members = [];
   for (const [index, root] of PROJECT_ROOTS.entries()) {
     const name = root.key;
@@ -45976,6 +46719,7 @@ function createRootType2(context) {
       )
     });
   }
+  members.push(dialogues);
   return {
     id: AnalyzerRootClassId,
     name: "Root",
@@ -46078,11 +46822,11 @@ function memberRuntimeType(record4, context, seen = /* @__PURE__ */ new Set(), g
       if (isMemberDialogueLookupBase(member) && isMultiSelectionMember(member)) {
         return {
           kind: "set",
-          elementType: primitive2("DialogueRef", true),
+          elementType: primitive2("string", true),
           nullable: !required
         };
       }
-      return primitive2("DialogueRef", required);
+      return primitive2("NeoDialogueReference", required);
     case 14 /* Vector2 */:
       return primitive2("Vector2", required);
     case 15 /* Vector2Int */:
@@ -46330,7 +47074,7 @@ function toLanguageType(type, context, genericEnvironment) {
     case 12 /* Audio */:
       return primitive2("AudioClipInfo", required);
     case 18 /* DialogueLookup */:
-      return primitive2("DialogueRef", required);
+      return primitive2("NeoDialogueReference", required);
     case 14 /* Vector2 */:
       return primitive2("Vector2", required);
     case 15 /* Vector2Int */:
@@ -46530,7 +47274,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}`,
@@ -46748,6 +47494,7 @@ function createAnalyzerProject(ctx) {
   return {
     project: ctx.project,
     projectFiles: [...ctx.projectFiles ?? []],
+    dialogueGroups: [...ctx.dialogueGroups ?? []],
     members,
     classes: [...ctx.classes],
     enums: [...ctx.enums],
@@ -46992,6 +47739,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],
@@ -47051,6 +47799,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],
@@ -47252,6 +48001,7 @@ function compilationProjectForDocument(document2, state) {
   state.compilationProject ??= createNeoScriptCompilationProject({
     project: document2.project,
     projectFiles: document2.projectFiles,
+    dialogueGroups: document2.dialogueGroups,
     members: document2.members,
     classes: document2.classes,
     enums: document2.enums,
@@ -47346,6 +48096,7 @@ function compileValueInitializerDependency(document2, valueId, compilationProjec
   compileValueRowInitializerBody({
     project: document2.project,
     projectFiles: document2.projectFiles,
+    dialogueGroups: document2.dialogueGroups,
     members: document2.members,
     classes: document2.classes,
     enums: document2.enums,
@@ -47364,6 +48115,7 @@ function compileMemberInitializerDependency(document2, memberId, compilationProj
   const compileArgs = {
     project: document2.project,
     projectFiles: document2.projectFiles,
+    dialogueGroups: document2.dialogueGroups,
     members: document2.members,
     classes: document2.classes,
     enums: document2.enums,
@@ -47512,7 +48264,7 @@ async function restartProjectRead(read) {
 // ../src/models/project/project-types.ts
 function isProject(value) {
   const v = value;
-  return typeof v?.name === "string" && typeof v?.id === "string" && isProjectOwner(v.owner) && isActorIdentifier(v.author) && typeof v?.createdAt === "number" && typeof v?.updatedAt === "number" && typeof v?.rootAssetsMemberId === "string" && typeof v?.rootSaveFileMemberId === "string" && typeof v?.rootSessionMemberId === "string" && typeof v?.rootUserMemberId === "string" && isOptionalNullableString2(v.defaultPriorityGroupId) && isOptionalNullableString2(v.defaultTextureTemplateId) && isOptionalNullableString2(v.defaultAudioClipTemplateId) && isProjectExportSettingsOrEmpty(v.exportSettings);
+  return typeof v?.name === "string" && typeof v?.id === "string" && isProjectOwner(v.owner) && isActorIdentifier(v.author) && typeof v?.createdAt === "number" && typeof v?.updatedAt === "number" && typeof v?.rootAssetsMemberId === "string" && typeof v?.rootSaveFileMemberId === "string" && typeof v?.rootSessionMemberId === "string" && typeof v?.rootUserMemberId === "string" && isOptionalNullableString3(v.defaultPriorityGroupId) && isOptionalNullableString3(v.defaultTextureTemplateId) && isOptionalNullableString3(v.defaultAudioClipTemplateId) && isProjectExportSettingsOrEmpty(v.exportSettings);
 }
 function isProjectOwner(value) {
   if (!isActorIdentifier(value)) return false;
@@ -47524,7 +48276,7 @@ function isProjectExportSettingsOrEmpty(value) {
   const settings = value;
   return isUnityExportSettingsOrEmpty(settings.unity);
 }
-function isOptionalNullableString2(value) {
+function isOptionalNullableString3(value) {
   if (value === void 0) return true;
   if (value === null) return true;
   return typeof value === "string";
@@ -47558,7 +48310,7 @@ function isProjectMigration(value) {
 }
 
 // ../src/models/variants/variants.ts
-function isNonEmptyString(value) {
+function isNonEmptyString2(value) {
   if (typeof value !== "string") return false;
   return value.length > 0;
 }
@@ -47566,151 +48318,28 @@ function isNeoClassVariant(value) {
   if (typeof value !== "object" || value === null) return false;
   if (Array.isArray(value)) return false;
   const v = value;
-  if (!isNonEmptyString(v.id)) return false;
-  if (!isNonEmptyString(v.classId)) return false;
-  if (!isNonEmptyString(v.name)) return false;
-  if (!isNonEmptyString(v.valueId)) return false;
-  if (v.folderId !== null && !isNonEmptyString(v.folderId)) return false;
+  if (!isNonEmptyString2(v.id)) return false;
+  if (!isNonEmptyString2(v.classId)) return false;
+  if (!isNonEmptyString2(v.name)) return false;
+  if (!isNonEmptyString2(v.valueId)) return false;
+  if (v.folderId !== null && !isNonEmptyString2(v.folderId)) return false;
   return true;
 }
 function isNeoClassVariantFolder(value) {
   if (typeof value !== "object" || value === null) return false;
   if (Array.isArray(value)) return false;
   const v = value;
-  if (!isNonEmptyString(v.id)) return false;
-  if (!isNonEmptyString(v.classId)) return false;
+  if (!isNonEmptyString2(v.id)) return false;
+  if (!isNonEmptyString2(v.classId)) return false;
   if (typeof v.path !== "string") return false;
   if (v.binding === void 0) return v.path.length > 0;
   if (typeof v.binding !== "object" || Array.isArray(v.binding)) return false;
   const binding = v.binding;
-  if (!isNonEmptyString(binding.collectionMemberId)) return false;
-  if (!isNonEmptyString(binding.collectionValueId)) return false;
+  if (!isNonEmptyString2(binding.collectionMemberId)) return false;
+  if (!isNonEmptyString2(binding.collectionValueId)) return false;
   return true;
 }
 
-// ../src/models/dialogue/dialogue-source-identifiers.ts
-function isDialogueSourceIdentifier(value) {
-  return isValidProjectSourceIdentifier(value);
-}
-
-// ../src/models/dialogue/logic-types.ts
-function isNSBoolGetter(value) {
-  if (!isNSGetter(value)) return false;
-  if (value.typeInfo.type !== 1 /* Bool */) return false;
-  return value.typeInfo.required === true;
-}
-function isNSVoidBody2(value) {
-  if (!isNSGetter(value)) return false;
-  if (value.typeInfo.type !== 0 /* Null */) return false;
-  return value.typeInfo.required === true;
-}
-function isUILogicCondition(value) {
-  const v = value;
-  if (typeof v !== "object") return false;
-  if (v === null) return false;
-  if (!isNonEmptyString2(v.id)) return false;
-  if (v.type !== 0 /* UI */) return false;
-  if (!isNSBoolGetter(v.getter)) return false;
-  return isUIRenderableCondition(v.getter);
-}
-function isCodeLogicCondition(value) {
-  const v = value;
-  if (typeof v !== "object") return false;
-  if (v === null) return false;
-  if (!isNonEmptyString2(v.id)) return false;
-  if (v.type !== 1 /* Code */) return false;
-  if (!isNonEmptyString2(v.sourceFunctionId)) return false;
-  if (!isDialogueSourceIdentifier(v.sourceFunctionName)) return false;
-  if (typeof v.code !== "string") return false;
-  return isNSBoolGetter(v.getter);
-}
-function isLogicCondition(value) {
-  return isUILogicCondition(value) || isCodeLogicCondition(value);
-}
-function isUILogicAction(value) {
-  const v = value;
-  if (typeof v !== "object") return false;
-  if (v === null) return false;
-  if (v.type !== 0 /* UI */) return false;
-  if (!isNSVoidBody2(v.action)) return false;
-  return isUIRenderableAction(v.action);
-}
-function isCodeLogicAction(value) {
-  const v = value;
-  if (typeof v !== "object") return false;
-  if (v === null) return false;
-  if (v.type !== 1 /* Code */) return false;
-  if (!isNonEmptyString2(v.sourceFunctionId)) return false;
-  if (!isDialogueSourceIdentifier(v.sourceFunctionName)) return false;
-  if (typeof v.code !== "string") return false;
-  return isNSVoidBody2(v.action);
-}
-function isNonEmptyString2(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function isLogicAction(value) {
-  return isUILogicAction(value) || isCodeLogicAction(value);
-}
-function isUIRenderableCondition(getter) {
-  if (getter.instructions.length !== 1) return false;
-  return getter.instructions[0]?.type === "return" /* return */;
-}
-function isUIRenderableAction(action) {
-  if (action.instructions.length === 0) return true;
-  if (action.instructions.length !== 1) return false;
-  const instruction = action.instructions[0];
-  if (!instruction) return false;
-  return instruction.type === "return" /* return */ || instruction.type === "assign" /* assign */ || instruction.type === "collectionCall" /* collectionCall */ || instruction.type === "functionCall" /* functionCall */;
-}
-
-// ../src/models/dialogue/dialogue-group-types.ts
-function isOptionalNullableString3(value) {
-  if (value === void 0) return true;
-  if (value === null) return true;
-  return typeof value === "string";
-}
-function isDialogueGroupType(value) {
-  return value === 0 /* Standard */ || value === 1 /* Lookup */ || value === 2 /* Folder */;
-}
-function isDialogueGroupBase(value, expectedType) {
-  const v = value;
-  if (typeof v !== "object") return false;
-  if (v === null) return false;
-  if (typeof v.name !== "string") return false;
-  if (!isDialogueGroupType(v.type)) return false;
-  if (expectedType !== void 0 && v.type !== expectedType) return false;
-  if (!isOptionalNullableString3(v.parentDialogueGroupId)) return false;
-  if (!Array.isArray(v.conditions)) return false;
-  if (!v.conditions.every(isLogicCondition)) return false;
-  return isOptionalNullableString3(v.priorityGroupIdOverride);
-}
-function isStandardDialogueGroupBase(value) {
-  return isDialogueGroupBase(value, 0 /* Standard */);
-}
-function isLookupDialogueGroupBase(value) {
-  const v = value;
-  if (!isDialogueGroupBase(value, 1 /* Lookup */)) return false;
-  if (typeof v?.collectionMemberId !== "string") return false;
-  return isOptionalNullableString3(v.collectionValueId);
-}
-function isFolderDialogueGroupBase(value) {
-  return isDialogueGroupBase(value, 2 /* Folder */);
-}
-function isDialogueGroupProps(value, expectedType) {
-  const v = value;
-  if (!isDialogueGroupBase(value, expectedType)) return false;
-  if (!isWithId(value)) return false;
-  if (!isIWithTimestamps(value)) return false;
-  return typeof v?.projectId === "string";
-}
-function isDialogueGroup(value, expectedType) {
-  return isDialogueGroupProps(value, expectedType);
-}
-function isAnyDialogueGroup(value) {
-  if (!isDialogueGroup(value)) return false;
-  return isStandardDialogueGroupBase(value) || isLookupDialogueGroupBase(value) || isFolderDialogueGroupBase(value);
-}
-
 // ../src/models/dialogue/dialogue-types.ts
 function isNonArrayObject(value) {
   if (!isRequiredType(value, isObject)) return false;
@@ -54658,7 +55287,7 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.72.2",
+  cliVersion: "0.73.0",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -56140,6 +56769,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],
@@ -56166,10 +56796,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,
+    (id) => members.get(id),
+    (id) => classes.get(id)
+  );
+}
 function compileCliNeoScript(uri, source, context, projectIndex) {
   const result = compileNeoScriptStrict(
     {
@@ -56404,7 +57049,7 @@ var WORLD_OBJECT_CONTRACT_WORLD_KINDS = /* @__PURE__ */ new Set([
 ]);
 
 // ../src/models/exports/unity-codegen-revision.ts
-var UNITY_CODEGEN_REVISION = "45a0847addd4616acfc29f142556dcb2e0a27daae14d6aa456430228e66dbc07";
+var UNITY_CODEGEN_REVISION = "e4a632a177c87244e19da71c9840b8007735773ae5f81578f58ce246ec6cb03d";
 
 // src/export-cache.ts
 var CACHE_BUILD = JSON.stringify([
@@ -56602,6 +57247,7 @@ function sharedEvaluatorBase(rawDocument) {
     variants: document2.variants,
     variantFolders: document2.variantFolders,
     projectFiles: document2.projectFiles,
+    dialogueGroups: document2.dialogueGroups,
     textureTemplates: document2.textureTemplates,
     localizationConfig: document2.localizationConfig,
     localizedTexts: document2.localizedTexts,