@neocompose/cli 0.71.1 → 0.71.2

package/dist/neo.mjs

@@ -14206,7 +14206,8 @@ var init_neoflow_graph_parser = __esm({
                 this.baseOffset + valueStartToken.start,
                 this.baseOffset + end.end
               ),
-              range: this.absoluteRange(start, end)
+              range: this.absoluteRange(start, end),
+              valueRange: this.absoluteRange(valueStartToken, end)
             });
           }
           if (!this.eat(",") && !this.at(")")) {
@@ -14405,6 +14406,12 @@ var init_neoflow_graph_parser = __esm({
               name: name.text,
               nameRange: this.absoluteRange(name, name),
               initializer,
+              initializerRange: {
+                start: this.source.positionAt(
+                  equalsOffset + this.source.text.slice(equalsOffset, this.baseOffset + last.start).indexOf(initializer)
+                ),
+                end: this.source.positionAt(this.baseOffset + last.start)
+              },
               range: this.absoluteRange(first, last)
             });
           } else {
@@ -15804,7 +15811,9 @@ var init_project_source_parser = __esm({
         const type = this.parseType();
         const name = this.expectName("global name");
         this.expect("=");
+        const initializerStart = this.cursor;
         const initializer = this.captureInitializer();
+        const dialogueGroup = type.name === "DialogueGroup" ? this.parseDialogueGroupBody(initializerStart, initializer) : void 0;
         this.reportNestedTypes(initializer);
         return {
           kind: "global",
@@ -15813,9 +15822,53 @@ var init_project_source_parser = __esm({
           name: name.text,
           nameRange: name.range,
           initializer,
+          ...dialogueGroup ? { dialogueGroup } : {},
           range: rangeFrom(start, this.previous())
         };
       }
+      parseDialogueGroupBody(start, initializer) {
+        const end = this.cursor;
+        let depth = 0;
+        let open = -1;
+        for (let index = start; index < end; index++) {
+          const text = this.tokens[index].text;
+          if (text === "(" || text === "[") depth++;
+          else if (text === ")" || text === "]") depth--;
+          else if (text === "{" && depth === 0) {
+            open = index;
+            break;
+          }
+        }
+        if (open < 0) return void 0;
+        const functions = [];
+        this.cursor = open + 1;
+        try {
+          while (!this.done() && !this.at("}") && !this.at("when") && this.cursor < end) {
+            const before = this.cursor;
+            try {
+              const member = this.parseMember("DialogueGroup", "class");
+              if (member?.kind === "function") functions.push(member);
+            } catch (error) {
+              this.report(error);
+              this.recoverMember();
+            }
+            if (this.cursor === before) this.cursor++;
+          }
+        } finally {
+          this.cursor = end;
+        }
+        const openToken = this.tokens[open];
+        return {
+          constructor: {
+            text: this.source.text.slice(
+              this.tokens[start].start,
+              openToken.start
+            ),
+            range: { start: initializer.range.start, end: openToken.range.start }
+          },
+          functions
+        };
+      }
       parseGenericParameters() {
         this.expect("<");
         const parameters = [];
@@ -20490,7 +20543,7 @@ function optionalTestConfig(value) {
       `"${NEO_CONFIG_FILE}" field "test.${unknown}" is not recognized.`
     );
   }
-  const stringArray2 = (field) => {
+  const stringArray3 = (field) => {
     const entry = config[field];
     if (entry === void 0) return void 0;
     if (!Array.isArray(entry) || entry.some((item) => typeof item !== "string" || item.length === 0)) {
@@ -20510,8 +20563,8 @@ function optionalTestConfig(value) {
     }
     return entry;
   };
-  const include = stringArray2("include");
-  const exclude = stringArray2("exclude");
+  const include = stringArray3("include");
+  const exclude = stringArray3("exclude");
   const invalidInclude = include?.find(
     (pattern) => !pattern.endsWith(".spec.neo")
   );
@@ -23195,7 +23248,7 @@ var init_project = __esm({
 });
 
 // ../packages/neoscript-language/src/source-map.ts
-function createNeoScriptSourceMap(code, fileText, range2, source) {
+function createNeoScriptSourceMap(code, fileText, range2, source, thisAlias) {
   const text = typeof fileText === "string" ? new SourceText(fileText) : fileText;
   const start = text.offsetAt(range2.start);
   const end = text.offsetAt(range2.end);
@@ -23218,7 +23271,8 @@ function createNeoScriptSourceMap(code, fileText, range2, source) {
   for (let i2 = first; i2 < last; i2++) {
     const body = canonical[i2];
     const file = authored[i2 - first];
-    if (body.kind !== file.kind || body.raw !== file.raw) return void 0;
+    if (body.kind !== file.kind || body.raw !== file.raw && !(body.kind === "identifier" && body.text === "this" && file.text === thisAlias))
+      return void 0;
     const at3 = position(file.start);
     positions.push([
       body.range.start.line + 1,
@@ -26062,6 +26116,7 @@ var init_strict_resolver = __esm({
       tryMutationContexts = [];
       functionControlBoundaries = [];
       debugSource;
+      inferredExpressionReturnType;
       initialScope() {
         const scope = new Scope(null, this.options.onFlowScope !== void 0);
         scope.define(
@@ -26266,6 +26321,23 @@ var init_strict_resolver = __esm({
             this.context.kind === "action" || this.context.kind === "setter" || this.context.kind === "constructor" || isVoid(this.context.returnType),
             describeUnitKind(this.context.kind)
           );
+          if (this.options.inferExpressionReturnType) {
+            if (this.context.kind !== "getter")
+              throw new CompileError(
+                "Expression inference requires a getter.",
+                body.pos
+              );
+            if (statements.length !== 1)
+              throw new CompileError(
+                "Expression inference requires one return expression.",
+                body.pos
+              );
+            if (statements[0]?.kind !== "return" || statements[0].expr === null)
+              throw new CompileError(
+                "Expression inference requires a returned value.",
+                body.pos
+              );
+          }
           const instructions = this.resolveStatements(statements, scope);
           if ((this.context.kind === "function" || this.context.kind === "getter" || this.context.kind === "condition" || this.context.kind === "initializer") && !isVoid(this.context.returnType) && !instructionsTerminate(instructions)) {
             throw new CompileError(
@@ -26282,7 +26354,10 @@ var init_strict_resolver = __esm({
             source: this.debugSource,
             parameters,
             instructions,
-            typeInfo: toWireType(returnType, this.project)
+            typeInfo: toWireType(
+              this.inferredExpressionReturnType ?? returnType,
+              this.project
+            )
           };
         } finally {
           this.expectedReturnStack.pop();
@@ -27084,10 +27159,11 @@ var init_strict_resolver = __esm({
             }
             const inference = this.lambdaReturnInference.at(-1);
             const inferring = inference?.depth === this.lambdaDepth;
+            const inferExpression = this.options.inferExpressionReturnType && this.lambdaDepth === 0;
             const value = this.resolveExpression(
               statement.expr,
               scope,
-              inferring ? void 0 : expected
+              inferring || inferExpression ? void 0 : expected
             );
             if (inferring) {
               inference.returns.push({
@@ -27107,12 +27183,21 @@ var init_strict_resolver = __esm({
                 statement.pos
               );
             }
-            this.requireAssignable(
-              value.type,
-              expected,
-              statement.expr.pos,
-              "return"
-            );
+            if (inferExpression) {
+              if (isVoid(value.type))
+                throw new CompileError(
+                  "A text expression must return a value, not void.",
+                  statement.expr.pos
+                );
+              this.inferredExpressionReturnType = value.type;
+            } else {
+              this.requireAssignable(
+                value.type,
+                expected,
+                statement.expr.pos,
+                "return"
+              );
+            }
             return {
               type: "return" /* Return */,
               pointer: value.pointer
@@ -40091,6 +40176,14 @@ function referenceTypeAssignable(actual, expected, environment) {
       )
     );
   }
+  const actualType = environment.projectIndex.typeByName.get(actual.name);
+  const expectedType = environment.projectIndex.typeByName.get(expected.name);
+  if (actualType && expectedType?.kind === "interface")
+    return isNeoScriptTypeAssignable(
+      { kind: "named", typeId: actualType.id },
+      { kind: "named", typeId: expectedType.id },
+      environment.projectIndex
+    );
   return classExtends(actual.name, expected.name, environment, /* @__PURE__ */ new Set());
 }
 function classExtends(actual, expected, environment, visited) {
@@ -40637,7 +40730,8 @@ function compileNeoScriptStrict(document, context, options = {}) {
       {
         source: options.source,
         onFlowScope: options.onFlowScope,
-        sourceUri: document.uri
+        sourceUri: document.uri,
+        inferExpressionReturnType: options.inferExpressionReturnType
       }
     ).compile(ast);
     const ir = attachDependencyManifest(
@@ -40965,13 +41059,60 @@ function isPrimitiveName(name) {
 }
 function compileProjectSourceBodies(documents) {
   const graph = buildProjectGraph(documents);
-  const projectIndex = createProjectIndex(graph.project);
+  const groupContexts = dialogueGroupContexts(documents, graph);
+  const project = {
+    ...graph.project,
+    types: [
+      ...graph.project.types,
+      ...[...groupContexts.values()].map((group) => group.contextType)
+    ]
+  };
+  const projectIndex = createProjectIndex(project);
   const bodies = [];
   const contexts = [];
   const diagnostics = [];
   for (const [uri, document] of documents) {
     if (document.kind !== "definition") continue;
     for (const declaration of document.declarations) {
+      if (declaration.kind === "global") {
+        const group = groupContexts.get(declaration);
+        if (group) {
+          for (const member of declaration.dialogueGroup?.functions ?? []) {
+            if (!member.body) continue;
+            const expression = member.body.expression;
+            compileBody({
+              uri,
+              document,
+              owner: { declaration },
+              memberName: member.name,
+              declarationRange: member.nameRange,
+              memberId: sourceIdentity2(
+                member.annotations,
+                `dialogue-group:${uri}:${declaration.name}:${member.name}`
+              ),
+              unit: "function",
+              range: expression?.range ?? innerBodyRange(document.sourceText, member.body.range),
+              ...expression ? { bodyMode: "expression" } : {},
+              context: {
+                project,
+                kind: "function",
+                returnType: { kind: "primitive", name: "bool" },
+                ...group.thisType ? { thisClass: group.thisType } : {},
+                dialogueContextType: {
+                  kind: "named",
+                  typeId: group.contextType.id
+                },
+                functionName: member.name
+              },
+              projectIndex,
+              bodies,
+              contexts,
+              diagnostics
+            });
+          }
+        }
+        continue;
+      }
       if (declaration.kind !== "class") continue;
       const owner = graph.declarationsByName.get(declaration.name);
       if (!owner) continue;
@@ -41003,7 +41144,7 @@ function compileProjectSourceBodies(documents) {
           unit: "constructor",
           range: innerBodyRange(document.sourceText, constructor2.body.range),
           context: {
-            project: graph.project,
+            project,
             declaringType,
             thisClass: declaringType,
             implicitMemberAccess: true,
@@ -41038,7 +41179,7 @@ function compileProjectSourceBodies(documents) {
           unit: "init",
           range: innerBodyRange(document.sourceText, initBlock.body.range),
           context: {
-            project: graph.project,
+            project,
             declaringType,
             thisClass: declaringType,
             implicitMemberAccess: true,
@@ -41065,7 +41206,7 @@ function compileProjectSourceBodies(documents) {
         if (!info) continue;
         const staticMember = member.modifiers.includes("static");
         const baseContext2 = {
-          project: graph.project,
+          project,
           declaringType,
           ...staticMember ? {} : { thisClass: declaringType },
           returnType: sourceTypeRef(member.type, owner, graph.typeIdsByName),
@@ -41134,7 +41275,78 @@ function compileProjectSourceBodies(documents) {
       }
     }
   }
-  return { project: graph.project, bodies, contexts, diagnostics };
+  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]))
+    ])
+  );
+  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
+            }
+          ]
+        }
+      });
+    }
+  }
+  return result;
 }
 function compileBody(args) {
   args.contexts.push({
@@ -41938,6 +42150,7 @@ var init_project_source_script_compiler = __esm({
     "use strict";
     init_project_source_settlement();
     init_debug_info();
+    init_executable_parser();
     init_compiler();
     init_declared_constructors();
     init_language_spec();
@@ -44950,7 +45163,9 @@ function memberManifest(uri, member) {
     modifiers: member.modifiers,
     annotations: manifestAnnotations(member.annotations),
     initializer: member.kind === "field" ? member.initializer?.text ?? null : null,
+    ...member.kind === "field" && member.initializer ? { initializerSource: { uri, range: member.initializer.range } } : {},
     body: member.kind === "field" ? null : member.body?.text ?? null,
+    ...member.kind !== "field" && member.body ? { bodySource: { uri, range: member.body.range } } : {},
     parameters: member.kind === "function" ? member.parameters.map(
       (parameter4) => manifestParameter(uri, parameter4)
     ) : []
@@ -44988,7 +45203,7 @@ function dialogueManifest(uri, declaration) {
       graphType: member.type.name,
       destination: member.flowInitializer?.body?.destination?.name ?? null,
       initializer: member.initializer?.text ?? "",
-      arguments: flowArguments(member.flowInitializer?.arguments ?? []),
+      arguments: flowArguments(uri, member.flowInitializer?.arguments ?? []),
       content: member.flowInitializer?.body?.kind === "block" ? dialogueContent(uri, member.flowInitializer.body.content) : null
     }))
   };
@@ -44996,18 +45211,20 @@ function dialogueManifest(uri, declaration) {
 function dialogueContent(uri, content) {
   return {
     prose: content.prose.map((entry) => entry.text),
+    proseSources: content.prose.map((entry) => ({ uri, range: entry.range })),
     bindings: content.bindings.map((binding) => ({
       name: binding.name,
       type: binding.typeText,
       primary: binding.primary,
-      initializer: binding.initializer
+      initializer: binding.initializer,
+      source: { uri, range: binding.initializerRange }
     })),
     children: content.children.map((child2) => ({
       ...identity(uri, child2.range, child2.annotations),
       name: child2.name,
       graphType: child2.graphType,
       destination: child2.initializer.body?.destination?.name ?? null,
-      arguments: flowArguments(child2.initializer.arguments),
+      arguments: flowArguments(uri, child2.initializer.arguments),
       content: child2.initializer.body?.kind === "block" ? dialogueContent(uri, child2.initializer.body.content) : null
     })),
     statements: content.statements.map((statement) => ({
@@ -45017,10 +45234,11 @@ function dialogueContent(uri, content) {
     }))
   };
 }
-function flowArguments(argumentsValue) {
+function flowArguments(uri, argumentsValue) {
   return argumentsValue.map((argument2) => ({
     ...argument2.name ? { name: argument2.name } : {},
-    expression: argument2.text
+    expression: argument2.text,
+    source: { uri, range: argument2.valueRange ?? argument2.range }
   }));
 }
 function manifestType(type) {
@@ -45389,9 +45607,13 @@ function assertMember(value, path) {
       "body",
       "parameters"
     ],
-    ["docsText"]
+    ["docsText", "bodySource", "initializerSource"]
   );
   assertIdentity(member, path);
+  if (member.initializerSource !== void 0)
+    assertLocation(member.initializerSource, `${path}.initializerSource`);
+  if (member.bodySource !== void 0)
+    assertLocation(member.bodySource, `${path}.bodySource`);
   string(member.name, `${path}.name`);
   assertOptionalDocsText(member.docsText, `${path}.docsText`);
   assertType(member.type, `${path}.type`);
@@ -45508,14 +45730,30 @@ function assertDialogue(value, path) {
 }
 function assertDialogueContent(value, path) {
   const content = record(value, path);
-  exactKeys(content, path, ["prose", "bindings", "children", "statements"]);
+  exactKeysWithOptional(
+    content,
+    path,
+    ["prose", "bindings", "children", "statements"],
+    ["proseSources"]
+  );
+  if (content.proseSources !== void 0)
+    array(content.proseSources, `${path}.proseSources`).forEach(
+      (entry, index) => assertLocation(entry, `${path}.proseSources[${index}]`)
+    );
   array(content.prose, `${path}.prose`).forEach(
     (entry, index) => string(entry, `${path}.prose[${index}]`)
   );
   array(content.bindings, `${path}.bindings`).forEach((entry, index) => {
     const bindingPath = `${path}.bindings[${index}]`;
     const binding = record(entry, bindingPath);
-    exactKeys(binding, bindingPath, ["name", "type", "primary", "initializer"]);
+    exactKeysWithOptional(
+      binding,
+      bindingPath,
+      ["name", "type", "primary", "initializer"],
+      ["source"]
+    );
+    if (binding.source !== void 0)
+      assertLocation(binding.source, `${bindingPath}.source`);
     string(binding.name, `${bindingPath}.name`);
     string(binding.type, `${bindingPath}.type`);
     if (typeof binding.primary !== "boolean") {
@@ -45573,11 +45811,12 @@ function assertFlowArguments(value, path) {
     exactKeys(
       argument2,
       argumentPath,
-      Object.hasOwn(argument2, "name") ? ["name", "expression"] : ["expression"]
+      Object.hasOwn(argument2, "name") ? ["name", "expression", "source"] : ["expression", "source"]
     );
     if (argument2.name !== void 0)
       string(argument2.name, `${argumentPath}.name`);
     string(argument2.expression, `${argumentPath}.expression`);
+    assertLocation(argument2.source, `${argumentPath}.source`);
   });
 }
 function assertType(value, path) {
@@ -45759,7 +45998,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.71.1",
+      cliVersion: "0.71.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -47208,7 +47447,7 @@ var init_source_diagnostics = __esm({
       "neoflow-incomplete-draft"
     ]);
     SchemaSourceError = class extends Error {
-      constructor(detail, file, line, column, code, severity = "error") {
+      constructor(detail, file, line, column, code, severity = "error", range2) {
         super(`${file}:${line}:${column} \u2014 ${detail}`);
         this.detail = detail;
         this.file = file;
@@ -47216,6 +47455,7 @@ var init_source_diagnostics = __esm({
         this.column = column;
         this.code = code;
         this.severity = severity;
+        this.range = range2;
         this.name = "SchemaSourceError";
       }
       detail;
@@ -47224,6 +47464,7 @@ var init_source_diagnostics = __esm({
       column;
       code;
       severity;
+      range;
     };
   }
 });
@@ -57633,6 +57874,8 @@ function isDialogueLogicCompileTextVariableContext(value) {
   if (!isNSPointer(v.pointer)) return false;
   if (typeof v.sourcePath !== "string") return false;
   if (!isNSTypeInfo(v.typeInfo)) return false;
+  if (v.sourceInline !== void 0 && typeof v.sourceInline !== "boolean")
+    return false;
   if (typeof v.variableId !== "string") return false;
   return isOptionalNullableString2(v.optionId);
 }
@@ -65451,6 +65694,898 @@ var init_dialogue_sources = __esm({
   }
 });
 
+// ../src/models/classes/constructor-parameter-settlement.ts
+function createConstructorSettlementResolver(view) {
+  const classesById = new Map(
+    view.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const membersById = new Map(
+    view.members.map((member) => [member.id, member])
+  );
+  const constructorsById = new Map(
+    (view.constructors ?? []).map((constructor2) => [
+      constructor2.id,
+      constructor2
+    ])
+  );
+  const directResultByClassAndParameter = /* @__PURE__ */ new Map();
+  const recordedResultByConstructorAndParameter = /* @__PURE__ */ new Map();
+  const directSettlement = (classId, parameterName) => {
+    const cacheKey = `${classId}\0${parameterName}`;
+    if (directResultByClassAndParameter.has(cacheKey)) {
+      return directResultByClassAndParameter.get(cacheKey) ?? null;
+    }
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = classId;
+    while (currentId !== null && !visited.has(currentId)) {
+      visited.add(currentId);
+      const schemaClass2 = classesById.get(currentId);
+      if (schemaClass2 === void 0) break;
+      for (const [schemaKey, memberId] of Object.entries(
+        schemaClass2.schema ?? {}
+      )) {
+        if (typeof memberId !== "string") continue;
+        const member = membersById.get(memberId);
+        const defaultRecord = asRecord(member?.defaultValue);
+        const initRecord = asRecord(defaultRecord?.init);
+        if (initRecord !== null && typeof initRecord.code === "string" && initRecord.code.trim() === parameterName) {
+          const result = { schemaKey, memberId };
+          directResultByClassAndParameter.set(cacheKey, result);
+          return result;
+        }
+      }
+      currentId = schemaClass2.extendsClassId ?? null;
+    }
+    directResultByClassAndParameter.set(cacheKey, null);
+    return null;
+  };
+  const memberIdForSchemaKey = (classId, schemaKey) => {
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = classId;
+    while (currentId !== null && !visited.has(currentId)) {
+      visited.add(currentId);
+      const schemaClass2 = classesById.get(currentId);
+      if (schemaClass2 === void 0) return null;
+      const memberId = schemaClass2.schema?.[schemaKey];
+      if (typeof memberId === "string") return memberId;
+      currentId = schemaClass2.extendsClassId ?? null;
+    }
+    return null;
+  };
+  const recordedSettlement = (classId, parameterName, constructorId, resolving) => {
+    const cacheKey = `${classId}\0${constructorId}\0${parameterName}`;
+    if (recordedResultByConstructorAndParameter.has(cacheKey)) {
+      return recordedResultByConstructorAndParameter.get(cacheKey) ?? null;
+    }
+    if (resolving.has(cacheKey)) return null;
+    const constructor2 = constructorsById.get(constructorId);
+    if (constructor2?.classId !== classId) {
+      recordedResultByConstructorAndParameter.set(cacheKey, null);
+      return null;
+    }
+    const direct = directSettlement(classId, parameterName);
+    if (direct !== null) {
+      recordedResultByConstructorAndParameter.set(cacheKey, direct);
+      return direct;
+    }
+    const schemaClass2 = classesById.get(classId);
+    const baseClassId = schemaClass2?.extendsClassId;
+    if (typeof baseClassId !== "string") {
+      recordedResultByConstructorAndParameter.set(cacheKey, null);
+      return null;
+    }
+    for (const field of constructor2.baseInitializerFields ?? []) {
+      const record7 = asRecord(field);
+      if (typeof record7?.name !== "string" || typeof record7.code !== "string" || record7.code.trim() !== parameterName) {
+        continue;
+      }
+      const memberId = memberIdForSchemaKey(baseClassId, record7.name);
+      if (memberId !== null) {
+        const result = { schemaKey: record7.name, memberId };
+        recordedResultByConstructorAndParameter.set(cacheKey, result);
+        return result;
+      }
+    }
+    const baseConstructorId = classesById.get(baseClassId)?.requiredConstructorId;
+    if (typeof baseConstructorId !== "string") {
+      recordedResultByConstructorAndParameter.set(cacheKey, null);
+      return null;
+    }
+    resolving.add(cacheKey);
+    for (const argument2 of constructor2.baseArguments ?? []) {
+      const record7 = asRecord(argument2);
+      if (typeof record7?.name !== "string" || typeof record7.code !== "string" || record7.code.trim() !== parameterName) {
+        continue;
+      }
+      const result = recordedSettlement(
+        baseClassId,
+        record7.name,
+        baseConstructorId,
+        resolving
+      );
+      resolving.delete(cacheKey);
+      recordedResultByConstructorAndParameter.set(cacheKey, result);
+      return result;
+    }
+    resolving.delete(cacheKey);
+    recordedResultByConstructorAndParameter.set(cacheKey, null);
+    return null;
+  };
+  return (classId, parameterName, constructorId) => constructorId === void 0 ? directSettlement(classId, parameterName) : recordedSettlement(classId, parameterName, constructorId, /* @__PURE__ */ new Set());
+}
+function constructorSettledSchemaEntry(view, classId, parameterName, constructorId) {
+  return createConstructorSettlementResolver(view)(
+    classId,
+    parameterName,
+    constructorId
+  );
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+var init_constructor_parameter_settlement = __esm({
+  "../src/models/classes/constructor-parameter-settlement.ts"() {
+    "use strict";
+  }
+});
+
+// ../src/database/neo-script-derived-bodies.ts
+function cloneAndStripClientDerivedBodies(change) {
+  if (change.operation === "delete" || change.nextData === void 0) {
+    return { ...change };
+  }
+  return {
+    ...change,
+    nextData: stripClientDerivedBodies(change.recordKind, change.nextData)
+  };
+}
+function stripClientDerivedBodies(recordKind, nextData) {
+  const record7 = asRecord2(nextData);
+  return record7 === null ? nextData : strippedClone(recordKind, record7);
+}
+function hasPendingNeoScriptDerivation(recordKind, data) {
+  const record7 = asRecord2(data);
+  if (record7 === null) return false;
+  return collectDerivedBodySites(recordKind, record7).some(
+    (site) => site.authored && !(site.key in site.container)
+  );
+}
+function strippedClone(recordKind, record7) {
+  const next = structuredClone(record7);
+  const container = asRecord2(next);
+  if (container === null) return next;
+  for (const site of collectDerivedBodySites(recordKind, container)) {
+    delete site.container[site.key];
+  }
+  return next;
+}
+function collectDerivedBodySites(recordKind, record7) {
+  const sites = [];
+  if (recordKind === "migration") {
+    sites.push({
+      container: record7,
+      key: "action",
+      authored: typeof record7.code === "string"
+    });
+    return sites;
+  }
+  if (recordKind === "dialogue-group") {
+    collectConditionSites(record7.conditions, sites);
+    return sites;
+  }
+  if (recordKind === "dialogue-node") {
+    collectDialogueNodeSites(record7, sites);
+    return sites;
+  }
+  if (recordKind === "constructor") {
+    sites.push({ container: record7, key: "action", authored: true });
+    sites.push({
+      container: record7,
+      key: "compiledBaseArguments",
+      authored: false
+    });
+    sites.push({
+      container: record7,
+      key: "compiledBaseInitializerFields",
+      authored: false
+    });
+    return sites;
+  }
+  if (recordKind === "value") {
+    collectValueBodySites(record7, sites);
+    return sites;
+  }
+  if (recordKind !== "member") return sites;
+  if (record7.kind === 10 /* NSProperty */) {
+    sites.push({
+      container: record7,
+      key: "getter",
+      authored: typeof record7.code === "string"
+    });
+    sites.push({
+      container: record7,
+      key: "setter",
+      authored: typeof record7.setterCode === "string"
+    });
+  }
+  if (record7.kind === 23 /* NSFunction */) {
+    sites.push({
+      container: record7,
+      key: "action",
+      authored: typeof record7.code === "string"
+    });
+  }
+  if (record7.kind === 25 /* NSDelegate */) {
+    collectDelegateClosureSite(asRecord2(record7.defaultValue), sites, false);
+  }
+  collectInitializerSite(asRecord2(record7.defaultValue), sites);
+  return sites;
+}
+function collectValueBodySites(record7, sites) {
+  collectInitializerSite(record7, sites);
+  collectDelegateClosureSite(record7, sites, true);
+  collectInlineDelegateArgumentSites(record7, sites);
+  for (const container of [record7.value, record7.constructorArgs]) {
+    if (container === null || typeof container !== "object") continue;
+    for (const candidate of Object.values(container)) {
+      if (!isPackedValueEnvelope(candidate)) continue;
+      const child2 = asRecord2(candidate[PACKED_VALUE_ENTRY_KEY]);
+      if (child2 !== null) collectValueBodySites(child2, sites);
+    }
+  }
+}
+function collectDialogueNodeSites(node, sites) {
+  collectConditionSites(node.conditions, sites);
+  collectTextVariableSites(node.variables, sites);
+  if (Array.isArray(node.actions)) {
+    for (const actionValue2 of node.actions) {
+      const logic = asRecord2(asRecord2(actionValue2)?.logic);
+      if (logic === null) continue;
+      if (logic.type !== 1 /* Code */) continue;
+      if (typeof logic.code !== "string") continue;
+      sites.push({ container: logic, key: "action", authored: true });
+    }
+  }
+  if (Array.isArray(node.outcomes)) {
+    for (const outcomeValue of node.outcomes) {
+      collectConditionSites(asRecord2(outcomeValue)?.conditions, sites);
+    }
+  }
+  const options = asRecord2(node.optionSettings)?.options;
+  if (!Array.isArray(options)) return;
+  for (const optionValue of options) {
+    const option = asRecord2(optionValue);
+    if (option === null) continue;
+    collectTextVariableSites(option.variables, sites);
+    const settings = asRecord2(option.settings);
+    if (settings === null) continue;
+    collectConditionSites(settings.conditions, sites);
+    collectConditionSites(settings.selectableConditions, sites);
+  }
+}
+function collectConditionSites(value, sites) {
+  if (!Array.isArray(value)) return;
+  for (const conditionValue of value) {
+    const condition = asRecord2(conditionValue);
+    if (condition === null) continue;
+    if (condition.type !== 1 /* Code */) continue;
+    if (typeof condition.code !== "string") continue;
+    sites.push({ container: condition, key: "getter", authored: true });
+  }
+}
+function collectTextVariableSites(value, sites) {
+  const variables = asRecord2(value);
+  if (variables === null) return;
+  for (const variableValue of Object.values(variables)) {
+    const variable2 = asRecord2(variableValue);
+    if (variable2 === null) continue;
+    sites.push({ container: variable2, key: "getter", authored: true });
+  }
+}
+function collectDelegateClosureSite(container, sites, authored) {
+  const delegate = asRecord2(container?.value);
+  if (delegate === null) return;
+  if (typeof delegate.code !== "string") return;
+  sites.push({ container: delegate, key: "action", authored });
+}
+function collectInlineDelegateArgumentSites(record7, sites) {
+  const constructorArgs = asRecord2(record7.constructorArgs);
+  if (constructorArgs === null) return;
+  for (const argument2 of Object.values(constructorArgs)) {
+    const closure = asRecord2(argument2);
+    if (closure === null) continue;
+    if (typeof closure.code !== "string") continue;
+    sites.push({ container: closure, key: "action", authored: true });
+  }
+}
+function collectInitializerSite(container, sites) {
+  const init = asRecord2(container?.init);
+  if (init === null) return;
+  sites.push({ container: init, key: "compiled", authored: true });
+}
+function stripDerivedBodies(member) {
+  return strippedClone("member", member);
+}
+function stripConstructorDerivedBodies(constructorRecord) {
+  return strippedClone("constructor", constructorRecord);
+}
+function stripMigrationAction(migration) {
+  return strippedClone("migration", migration);
+}
+function stampUILogicBody(logic, bodyKey) {
+  if (logic?.type !== 0 /* UI */) return false;
+  const body = asRecord2(logic[bodyKey]);
+  if (body === null) return false;
+  if (body.compilerRevision === NEOSCRIPT_COMPILER_REVISION) return false;
+  body.compilerRevision = NEOSCRIPT_COMPILER_REVISION;
+  return true;
+}
+function stampUILogicBodies(recordKind, data) {
+  const record7 = asRecord2(data);
+  if (record7 === null) return false;
+  if (recordKind === "dialogue-group") {
+    return stampConditionList(record7.conditions);
+  }
+  if (recordKind !== "dialogue-node") return false;
+  let changed = stampConditionList(record7.conditions);
+  if (Array.isArray(record7.actions)) {
+    for (const actionValue2 of record7.actions) {
+      const logic = asRecord2(asRecord2(actionValue2)?.logic);
+      changed = stampUILogicBody(logic, "action") || changed;
+    }
+  }
+  if (Array.isArray(record7.outcomes)) {
+    for (const outcomeValue of record7.outcomes) {
+      changed = stampConditionList(asRecord2(outcomeValue)?.conditions) || changed;
+    }
+  }
+  const options = asRecord2(record7.optionSettings)?.options;
+  if (Array.isArray(options)) {
+    for (const optionValue of options) {
+      const settings = asRecord2(asRecord2(optionValue)?.settings);
+      if (settings === null) continue;
+      changed = stampConditionList(settings.conditions) || changed;
+      changed = stampConditionList(settings.selectableConditions) || changed;
+    }
+  }
+  return changed;
+}
+function stampConditionList(value) {
+  if (!Array.isArray(value)) return false;
+  let changed = false;
+  for (const conditionValue of value) {
+    changed = stampUILogicBody(asRecord2(conditionValue), "getter") || changed;
+  }
+  return changed;
+}
+function asRecord2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+var init_neo_script_derived_bodies = __esm({
+  "../src/database/neo-script-derived-bodies.ts"() {
+    "use strict";
+    init_members();
+    init_logic_types();
+    init_strict_ir();
+    init_packed_value_encoding();
+  }
+});
+
+// src/project-source/stored-value-placements.ts
+function storedValueRowsByIdV4(records2) {
+  const stored = /* @__PURE__ */ new Map();
+  let packed = false;
+  for (const record7 of records2) {
+    if (record7.deleted === true) continue;
+    if (record7.recordKind !== "value") continue;
+    if (!isObjectRecord2(record7.data)) continue;
+    stored.set(record7.recordId, record7.data);
+    packed ||= rowCarriesPackedValueContent(record7.data);
+  }
+  if (!packed) return stored;
+  const logical = /* @__PURE__ */ new Map();
+  for (const [valueId, row] of stored) {
+    if (!rowCarriesPackedValueContent(row)) {
+      logical.set(valueId, row);
+      continue;
+    }
+    const authoredRow = stripClientDerivedBodies("value", row);
+    if (!isMemberValue(authoredRow)) {
+      throw new PackedValueEncodingError(
+        `Stored value row "${valueId}" packs a child but is not a well-formed value row, so its packed payload cannot be expanded.`
+      );
+    }
+    const decoded = decodePackedValueRow(authoredRow);
+    logical.set(valueId, { ...decoded.row });
+    for (const child2 of decoded.children) {
+      logical.set(child2.id, { ...child2 });
+    }
+  }
+  return logical;
+}
+function buildStoredValuePlacementIndexV4(records2, logicalValues) {
+  const live = [...records2].filter((record7) => record7.deleted !== true);
+  const values = logicalValues ?? storedValueRowsByIdV4(live);
+  const classes = [];
+  const members = [];
+  const memberDataById = /* @__PURE__ */ new Map();
+  const constructors = /* @__PURE__ */ new Map();
+  const variantTargetClassByRootValueId = /* @__PURE__ */ new Map();
+  for (const record7 of live) {
+    if (!isObjectRecord2(record7.data)) continue;
+    if (record7.recordKind === "value") continue;
+    if (record7.recordKind === "class") {
+      classes.push({
+        id: record7.recordId,
+        ...isStringRecord3(record7.data.schema) ? { schema: record7.data.schema } : {},
+        ...typeof record7.data.extendsClassId === "string" || record7.data.extendsClassId === null ? { extendsClassId: record7.data.extendsClassId } : {},
+        ...typeof record7.data.requiredConstructorId === "string" ? { requiredConstructorId: record7.data.requiredConstructorId } : {},
+        ...Array.isArray(record7.data.genericParams) ? {
+          genericParamIds: record7.data.genericParams.flatMap(
+            (entry) => isObjectRecord2(entry) && typeof entry.id === "string" ? [entry.id] : []
+          )
+        } : {}
+      });
+    } else if (record7.recordKind === "member") {
+      memberDataById.set(record7.recordId, record7.data);
+      members.push({
+        id: record7.recordId,
+        ...record7.data.defaultValue === void 0 ? {} : { defaultValue: record7.data.defaultValue }
+      });
+    } else if (record7.recordKind === "constructor") {
+      constructors.set(record7.recordId, record7.data);
+    } else if (record7.recordKind === "variant" && typeof record7.data.valueId === "string" && typeof record7.data.classId === "string") {
+      variantTargetClassByRootValueId.set(
+        record7.data.valueId,
+        record7.data.classId
+      );
+    }
+  }
+  const classesById = new Map(
+    classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const resolveSettlement = createConstructorSettlementResolver({
+    classes,
+    constructors: [...constructors].flatMap(
+      ([id2, constructor2]) => typeof constructor2.classId === "string" ? [
+        {
+          id: id2,
+          classId: constructor2.classId,
+          ...Array.isArray(constructor2.baseArguments) ? { baseArguments: constructor2.baseArguments } : {},
+          ...Array.isArray(constructor2.baseInitializerFields) ? {
+            baseInitializerFields: constructor2.baseInitializerFields
+          } : {}
+        }
+      ] : []
+    ),
+    members
+  });
+  const memberIdForSchemaKey = (classId, schemaKey) => {
+    const visited = /* @__PURE__ */ new Set();
+    let cursor = classId;
+    while (cursor !== null && !visited.has(cursor)) {
+      visited.add(cursor);
+      const schemaClass2 = classesById.get(cursor);
+      if (schemaClass2 === void 0) return null;
+      const memberId = schemaClass2.schema?.[schemaKey];
+      if (typeof memberId === "string") return memberId;
+      cursor = schemaClass2.extendsClassId ?? null;
+    }
+    return null;
+  };
+  const childrenByParentValueId = /* @__PURE__ */ new Map();
+  const placementByChildValueId = /* @__PURE__ */ new Map();
+  const add = (edge) => {
+    const children = childrenByParentValueId.get(edge.parentValueId) ?? /* @__PURE__ */ new Map();
+    if (children.has(edge.schemaKey)) return;
+    children.set(edge.schemaKey, edge);
+    childrenByParentValueId.set(edge.parentValueId, children);
+    if (!placementByChildValueId.has(edge.childValueId)) {
+      placementByChildValueId.set(edge.childValueId, edge);
+    }
+  };
+  for (const [parentValueId, value] of values) {
+    const classId = typeof value.classId === "string" ? value.classId : null;
+    const body = value.value;
+    if (isObjectRecord2(body)) {
+      for (const [schemaKey, childValueId2] of Object.entries(body)) {
+        if (typeof childValueId2 !== "string" || !values.has(childValueId2)) {
+          continue;
+        }
+        add({
+          childValueId: childValueId2,
+          memberId: classId === null ? null : memberIdForSchemaKey(classId, schemaKey),
+          parentValueId,
+          schemaKey,
+          source: "body"
+        });
+      }
+    }
+    const constructorId = value.instanceConstructorId;
+    const constructorArgs = value.constructorArgs;
+    if (classId === null || typeof constructorId !== "string" || !isObjectRecord2(constructorArgs)) {
+      continue;
+    }
+    const constructor2 = constructors.get(constructorId);
+    const parameters = constructor2?.argumentTypes;
+    if (constructor2 === void 0 || constructor2.classId !== classId || !Array.isArray(parameters)) {
+      continue;
+    }
+    for (const [index, parameter4] of parameters.entries()) {
+      if (!isObjectRecord2(parameter4) || typeof parameter4.name !== "string") {
+        continue;
+      }
+      const settled = resolveSettlement(classId, parameter4.name, constructorId);
+      if (settled === null) continue;
+      if (isObjectRecord2(body) && Object.hasOwn(body, settled.schemaKey)) {
+        continue;
+      }
+      const parameterId = constructorActionParameterId(constructor2, index);
+      const childValueId2 = constructorArgs[parameterId];
+      if (typeof childValueId2 !== "string" || !values.has(childValueId2) || !memberStoresAggregate(
+        memberDataById.get(settled.memberId),
+        value,
+        memberDataById,
+        parentValueId,
+        classesById,
+        variantTargetClassByRootValueId
+      )) {
+        continue;
+      }
+      add({
+        childValueId: childValueId2,
+        memberId: settled.memberId,
+        parentValueId,
+        schemaKey: settled.schemaKey,
+        source: "constructor"
+      });
+    }
+  }
+  return { childrenByParentValueId, placementByChildValueId };
+}
+function memberStoresAggregate(member, parent, membersById, parentValueId, classesById, variantTargetClassByRootValueId, visitedMemberIds = /* @__PURE__ */ new Set()) {
+  const kind = member?.kind;
+  if (kind === 5 /* Dictionary */ || kind === 6 /* List */ || kind === 7 /* Class */ || kind === "dictionary" || kind === "list" || kind === "class") {
+    return true;
+  }
+  if (kind !== 21 /* Generic */ && kind !== "generic") return false;
+  const memberId = typeof member?.id === "string" ? member.id : null;
+  if (memberId !== null && visitedMemberIds.has(memberId)) return false;
+  const genericParamId = member?.genericParamId;
+  const bindings = parent.genericBindings;
+  if (typeof genericParamId === "string" && isObjectRecord2(bindings)) {
+    const bindingMemberId = bindings[genericParamId];
+    if (typeof bindingMemberId === "string") {
+      return memberStoresAggregate(
+        membersById.get(bindingMemberId),
+        parent,
+        membersById,
+        parentValueId,
+        classesById,
+        variantTargetClassByRootValueId,
+        /* @__PURE__ */ new Set([
+          ...visitedMemberIds,
+          ...memberId === null ? [] : [memberId]
+        ])
+      );
+    }
+  }
+  const parentClassId = parent.classId;
+  const variantTargetClassId = variantTargetClassByRootValueId.get(parentValueId);
+  if (typeof parentClassId === "string" && typeof variantTargetClassId === "string" && classesById.get(parentClassId)?.genericParamIds?.[0] === genericParamId && classesById.has(variantTargetClassId)) {
+    return true;
+  }
+  return false;
+}
+function isStringRecord3(value) {
+  return isObjectRecord2(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+var init_stored_value_placements = __esm({
+  "src/project-source/stored-value-placements.ts"() {
+    "use strict";
+    init_constructors2();
+    init_constructor_parameter_settlement();
+    init_members();
+    init_neo_script_derived_bodies();
+    init_value_comparison();
+  }
+});
+
+// src/project-source/reference-target-types.ts
+function stringArray2(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+var ReferenceTargetTypes;
+var init_reference_target_types = __esm({
+  "src/project-source/reference-target-types.ts"() {
+    "use strict";
+    init_value_graph();
+    init_project();
+    init_codecs();
+    init_document_adapters();
+    init_members();
+    init_projection();
+    init_value_comparison();
+    init_stored_value_placements();
+    ReferenceTargetTypes = class {
+      constructor(state, seeds = /* @__PURE__ */ new Map(), pendingRows = [], manifest) {
+        this.state = state;
+        this.manifest = manifest;
+        for (const [memberId, seed] of seeds) {
+          if (seed.valueId)
+            this.overlay.set(seed.valueId, {
+              id: seed.valueId,
+              memberId,
+              ...encodeStoredValueNode(seed)
+            });
+          for (const row of seed.values ?? [])
+            this.overlay.set(row.id, {
+              id: row.id,
+              memberId: row.memberId,
+              ...encodeStoredValueRowFields(row)
+            });
+        }
+        for (const row of pendingRows)
+          this.overlay.set(row.id, {
+            id: row.id,
+            memberId: row.memberId,
+            ...encodeStoredValueRowFields(row)
+          });
+        const types = [];
+        this.manifestMembers = manifest && new Map(manifest.members.map((member) => [member.id, member]));
+        if (manifest) {
+          for (const type of manifest.classes) {
+            this.classes.set(type.id, type);
+            types.push({
+              id: type.id,
+              name: type.name,
+              kind: "class",
+              members: [],
+              baseTypeIds: type.extendsClassId ? [type.extendsClassId] : [],
+              interfaceTypeIds: type.implementsInterfaceIds
+            });
+          }
+          for (const type of manifest.interfaces)
+            types.push({
+              id: type.id,
+              name: type.name,
+              kind: "interface",
+              members: [],
+              baseTypeIds: type.extendsInterfaceIds
+            });
+          for (const type of manifest.enums)
+            types.push({ id: type.id, name: type.name, kind: "enum", members: [] });
+        } else {
+          for (const record7 of Object.values(state)) {
+            if (record7.recordKind !== "class" && record7.recordKind !== "interface" && record7.recordKind !== "enum")
+              continue;
+            const data = effectiveRecordData(record7);
+            if (!isObjectRecord2(data) || typeof data.name !== "string") continue;
+            if (record7.recordKind === "class")
+              this.classes.set(record7.recordId, data);
+            types.push({
+              id: record7.recordId,
+              name: data.name,
+              kind: record7.recordKind,
+              members: [],
+              baseTypeIds: typeof data.extendsClassId === "string" ? [data.extendsClassId] : stringArray2(data.extendsInterfaceIds),
+              interfaceTypeIds: stringArray2(data.implementsInterfaceIds)
+            });
+          }
+        }
+        this.project = createProjectIndex({
+          version: 1,
+          types,
+          globals: [],
+          roots: []
+        });
+      }
+      state;
+      manifest;
+      classes = /* @__PURE__ */ new Map();
+      schemaMembers = /* @__PURE__ */ new Map();
+      members = /* @__PURE__ */ new Map();
+      overlay = /* @__PURE__ */ new Map();
+      manifestMembers;
+      directOwners;
+      orderedParents;
+      values;
+      placements;
+      records;
+      project;
+      targetTypes = /* @__PURE__ */ new Map();
+      ownerCache = /* @__PURE__ */ new Map();
+      compatibility = /* @__PURE__ */ new Map();
+      stored(kind, id2) {
+        const record7 = this.state[`${kind}:${id2}`];
+        const data = record7 && effectiveRecordData(record7);
+        return isObjectRecord2(data) ? data : void 0;
+      }
+      member(id2) {
+        const cached = this.members.get(id2);
+        if (cached !== void 0) return cached ?? void 0;
+        const base = this.stored("member", id2);
+        const authored = this.manifestMembers?.get(id2);
+        const data = authored ? memberToDocument(
+          authored,
+          base,
+          this.manifestMembers?.get(authored.overrideOf ?? "")
+        ) : base;
+        this.members.set(id2, data ?? null);
+        return data;
+      }
+      buildRecords() {
+        const records2 = new Map(
+          Object.values(this.state).map((record7) => [
+            `${record7.recordKind}:${record7.recordId}`,
+            {
+              recordKind: record7.recordKind,
+              recordId: record7.recordId,
+              data: effectiveRecordData(record7)
+            }
+          ])
+        );
+        if (this.manifest)
+          for (const record7 of projectSchemaManifestToDocuments(this.manifest, {
+            baseRecord: (kind, id2) => {
+              const data = this.stored(kind, id2);
+              return data ? { recordKind: kind, recordId: id2, data } : null;
+            }
+          }))
+            records2.set(`${record7.recordKind}:${record7.recordId}`, record7);
+        for (const [id2, data] of this.overlay)
+          records2.set(`value:${id2}`, { recordKind: "value", recordId: id2, data });
+        return [...records2.values()];
+      }
+      readValues() {
+        return this.values ??= storedValueRowsByIdV4(
+          this.records ??= this.buildRecords()
+        );
+      }
+      value(id2) {
+        return this.overlay.get(id2) ?? this.stored("value", id2) ?? this.readValues().get(id2);
+      }
+      readPlacements() {
+        return this.placements ??= buildStoredValuePlacementIndexV4(
+          this.records ??= this.buildRecords(),
+          this.readValues()
+        );
+      }
+      readDirectOwners() {
+        if (this.directOwners) return this.directOwners;
+        const owners = /* @__PURE__ */ new Map();
+        const ids = this.manifestMembers?.keys() ?? Object.values(this.state).filter((record7) => record7.recordKind === "member").map((record7) => record7.recordId);
+        for (const id2 of ids) {
+          const member = this.stored("member", id2);
+          if (typeof member?.valueId === "string") owners.set(member.valueId, id2);
+        }
+        return this.directOwners = owners;
+      }
+      readOrderedParents() {
+        if (this.orderedParents) return this.orderedParents;
+        const parents = /* @__PURE__ */ new Map();
+        const values = this.readValues();
+        for (const [id2, row] of values) {
+          if (!Array.isArray(row.value)) continue;
+          for (const child2 of row.value) {
+            if (typeof child2 !== "string" || !values.has(child2)) continue;
+            const entries = parents.get(child2) ?? [];
+            entries.push(id2);
+            parents.set(child2, entries);
+          }
+        }
+        return this.orderedParents = parents;
+      }
+      assertAssignable(valueId, expectedName, label) {
+        let target = this.targetTypes.get(valueId);
+        if (!target) {
+          const value = this.value(valueId);
+          const owner = value && typeof value.classId !== "string" ? this.owner(valueId, /* @__PURE__ */ new Set()) : void 0;
+          const typeId = typeof value?.classId === "string" ? value.classId : owner?.classId ?? owner?.enumId;
+          target = {
+            exists: value !== void 0,
+            typeId: typeof typeId === "string" ? typeId : void 0
+          };
+          this.targetTypes.set(valueId, target);
+        }
+        if (!target.exists)
+          throw new Error(
+            `${label} references unresolved value ${JSON.stringify(valueId)}.`
+          );
+        const classId = target.typeId;
+        const actual = typeof classId === "string" ? this.project.typeById.get(classId) : void 0;
+        const expected = this.project.typeByName.get(expectedName);
+        if (!expected)
+          throw new Error(`${label} has unknown target type ${expectedName}.`);
+        const key = `${actual?.id}:${expected.id}`;
+        let compatible = this.compatibility.get(key);
+        if (compatible === void 0) {
+          compatible = actual !== void 0 && isNeoScriptTypeAssignable(
+            { kind: "named", typeId: actual.id },
+            { kind: "named", typeId: expected.id },
+            this.project
+          );
+          this.compatibility.set(key, compatible);
+        }
+        if (!compatible)
+          throw new Error(
+            `${label} target ${JSON.stringify(valueId)} has type ${actual?.name ?? "non-class value"}; expected ${expectedName}.`
+          );
+      }
+      collectionEntryTypeName(collectionId) {
+        const collection = this.member(collectionId);
+        if (collection?.kind !== 6 /* List */ && collection?.kind !== 5 /* Dictionary */)
+          return null;
+        const entry = typeof collection.entryMemberId === "string" ? this.member(collection.entryMemberId) : void 0;
+        return typeof entry?.classId === "string" ? this.project.typeById.get(entry.classId)?.name ?? null : null;
+      }
+      schemaMember(classId, key) {
+        const cacheKey = `${classId}:${key}`;
+        const cached = this.schemaMembers.get(cacheKey);
+        if (cached !== void 0) return cached;
+        const visited = /* @__PURE__ */ new Set();
+        let current = classId;
+        while (current && !visited.has(current)) {
+          visited.add(current);
+          const declaration = this.classes.get(current);
+          const id2 = isObjectRecord2(declaration?.schema) ? declaration.schema[key] : void 0;
+          if (typeof id2 === "string") {
+            this.schemaMembers.set(cacheKey, id2);
+            return id2;
+          }
+          current = typeof declaration?.extendsClassId === "string" ? declaration.extendsClassId : void 0;
+        }
+        this.schemaMembers.set(cacheKey, null);
+        return null;
+      }
+      owner(valueId, visiting) {
+        const cached = this.ownerCache.get(valueId);
+        if (cached !== void 0)
+          return cached === null ? void 0 : this.member(cached);
+        if (visiting.has(valueId)) return void 0;
+        visiting.add(valueId);
+        const row = this.value(valueId);
+        let memberId = typeof row?.memberId === "string" ? row.memberId : this.readDirectOwners().get(valueId);
+        if (!memberId)
+          memberId = this.readPlacements().placementByChildValueId.get(valueId)?.memberId;
+        if (!memberId) {
+          const placement = this.readPlacements().placementByChildValueId.get(valueId);
+          const row2 = this.value(valueId);
+          const parentId = placement?.parentValueId ?? (typeof row2?.containerId === "string" ? row2.containerId : void 0);
+          const parent = parentId ? this.owner(parentId, visiting) : void 0;
+          if (parent?.kind === 6 /* List */ || parent?.kind === 5 /* Dictionary */) {
+            if (typeof parent.entryMemberId === "string")
+              memberId = parent.entryMemberId;
+          } else if (placement && parentId) {
+            const parentValue = this.value(parentId);
+            const classId = typeof parentValue?.classId === "string" ? parentValue.classId : parent?.classId;
+            if (typeof classId === "string")
+              memberId = this.schemaMember(classId, placement.schemaKey);
+          }
+        }
+        if (!memberId) {
+          for (const parentId of this.readOrderedParents().get(valueId) ?? []) {
+            const parent = this.owner(parentId, visiting);
+            if (parent?.kind === 6 /* List */ && typeof parent.entryMemberId === "string") {
+              memberId = parent.entryMemberId;
+              break;
+            }
+          }
+        }
+        visiting.delete(valueId);
+        this.ownerCache.set(valueId, memberId ?? null);
+        return memberId ? this.member(memberId) : void 0;
+      }
+    };
+  }
+});
+
 // ../packages/neoscript-language/src/document-scaffold.ts
 var init_document_scaffold = __esm({
   "../packages/neoscript-language/src/document-scaffold.ts"() {
@@ -69080,144 +70215,6 @@ var init_initializer_dependencies = __esm({
   }
 });
 
-// ../src/models/classes/constructor-parameter-settlement.ts
-function createConstructorSettlementResolver(view) {
-  const classesById = new Map(
-    view.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
-  const membersById = new Map(
-    view.members.map((member) => [member.id, member])
-  );
-  const constructorsById = new Map(
-    (view.constructors ?? []).map((constructor2) => [
-      constructor2.id,
-      constructor2
-    ])
-  );
-  const directResultByClassAndParameter = /* @__PURE__ */ new Map();
-  const recordedResultByConstructorAndParameter = /* @__PURE__ */ new Map();
-  const directSettlement = (classId, parameterName) => {
-    const cacheKey = `${classId}\0${parameterName}`;
-    if (directResultByClassAndParameter.has(cacheKey)) {
-      return directResultByClassAndParameter.get(cacheKey) ?? null;
-    }
-    const visited = /* @__PURE__ */ new Set();
-    let currentId = classId;
-    while (currentId !== null && !visited.has(currentId)) {
-      visited.add(currentId);
-      const schemaClass2 = classesById.get(currentId);
-      if (schemaClass2 === void 0) break;
-      for (const [schemaKey, memberId] of Object.entries(
-        schemaClass2.schema ?? {}
-      )) {
-        if (typeof memberId !== "string") continue;
-        const member = membersById.get(memberId);
-        const defaultRecord = asRecord(member?.defaultValue);
-        const initRecord = asRecord(defaultRecord?.init);
-        if (initRecord !== null && typeof initRecord.code === "string" && initRecord.code.trim() === parameterName) {
-          const result = { schemaKey, memberId };
-          directResultByClassAndParameter.set(cacheKey, result);
-          return result;
-        }
-      }
-      currentId = schemaClass2.extendsClassId ?? null;
-    }
-    directResultByClassAndParameter.set(cacheKey, null);
-    return null;
-  };
-  const memberIdForSchemaKey = (classId, schemaKey) => {
-    const visited = /* @__PURE__ */ new Set();
-    let currentId = classId;
-    while (currentId !== null && !visited.has(currentId)) {
-      visited.add(currentId);
-      const schemaClass2 = classesById.get(currentId);
-      if (schemaClass2 === void 0) return null;
-      const memberId = schemaClass2.schema?.[schemaKey];
-      if (typeof memberId === "string") return memberId;
-      currentId = schemaClass2.extendsClassId ?? null;
-    }
-    return null;
-  };
-  const recordedSettlement = (classId, parameterName, constructorId, resolving) => {
-    const cacheKey = `${classId}\0${constructorId}\0${parameterName}`;
-    if (recordedResultByConstructorAndParameter.has(cacheKey)) {
-      return recordedResultByConstructorAndParameter.get(cacheKey) ?? null;
-    }
-    if (resolving.has(cacheKey)) return null;
-    const constructor2 = constructorsById.get(constructorId);
-    if (constructor2?.classId !== classId) {
-      recordedResultByConstructorAndParameter.set(cacheKey, null);
-      return null;
-    }
-    const direct = directSettlement(classId, parameterName);
-    if (direct !== null) {
-      recordedResultByConstructorAndParameter.set(cacheKey, direct);
-      return direct;
-    }
-    const schemaClass2 = classesById.get(classId);
-    const baseClassId = schemaClass2?.extendsClassId;
-    if (typeof baseClassId !== "string") {
-      recordedResultByConstructorAndParameter.set(cacheKey, null);
-      return null;
-    }
-    for (const field of constructor2.baseInitializerFields ?? []) {
-      const record7 = asRecord(field);
-      if (typeof record7?.name !== "string" || typeof record7.code !== "string" || record7.code.trim() !== parameterName) {
-        continue;
-      }
-      const memberId = memberIdForSchemaKey(baseClassId, record7.name);
-      if (memberId !== null) {
-        const result = { schemaKey: record7.name, memberId };
-        recordedResultByConstructorAndParameter.set(cacheKey, result);
-        return result;
-      }
-    }
-    const baseConstructorId = classesById.get(baseClassId)?.requiredConstructorId;
-    if (typeof baseConstructorId !== "string") {
-      recordedResultByConstructorAndParameter.set(cacheKey, null);
-      return null;
-    }
-    resolving.add(cacheKey);
-    for (const argument2 of constructor2.baseArguments ?? []) {
-      const record7 = asRecord(argument2);
-      if (typeof record7?.name !== "string" || typeof record7.code !== "string" || record7.code.trim() !== parameterName) {
-        continue;
-      }
-      const result = recordedSettlement(
-        baseClassId,
-        record7.name,
-        baseConstructorId,
-        resolving
-      );
-      resolving.delete(cacheKey);
-      recordedResultByConstructorAndParameter.set(cacheKey, result);
-      return result;
-    }
-    resolving.delete(cacheKey);
-    recordedResultByConstructorAndParameter.set(cacheKey, null);
-    return null;
-  };
-  return (classId, parameterName, constructorId) => constructorId === void 0 ? directSettlement(classId, parameterName) : recordedSettlement(classId, parameterName, constructorId, /* @__PURE__ */ new Set());
-}
-function constructorSettledSchemaEntry(view, classId, parameterName, constructorId) {
-  return createConstructorSettlementResolver(view)(
-    classId,
-    parameterName,
-    constructorId
-  );
-}
-function asRecord(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return null;
-  }
-  return value;
-}
-var init_constructor_parameter_settlement = __esm({
-  "../src/models/classes/constructor-parameter-settlement.ts"() {
-    "use strict";
-  }
-});
-
 // ../src/models/members/lookup-declared-type.ts
 function lookupDeclaredTypeInfo(member, collectionTypeInfo) {
   if (collectionTypeInfo === null) return null;
@@ -70117,7 +71114,7 @@ function collectSoftOwnedConstructorArgumentValueIds(index, ownerValueId, preser
           collectTypedRow(childId, typeInfo.entryTypeInfo);
         }
       }
-    } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord3(row.value)) {
+    } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord4(row.value)) {
       for (const childId of Object.values(row.value)) {
         collectTypedRow(childId, typeInfo.entryTypeInfo);
       }
@@ -70139,7 +71136,7 @@ function collectSoftOwnedConstructorArgumentValueIds(index, ownerValueId, preser
     collectNestedConstructorArguments(valueId);
   };
   const collectClassChildren = (row, typeInfo) => {
-    if (!isStringRecord3(row.value)) return;
+    if (!isStringRecord4(row.value)) return;
     const effectiveClassId = row.classId ?? (typeInfo.type === 7 /* Class */ ? typeInfo.classId : void 0);
     if (effectiveClassId === void 0) return;
     const env = rowGenericEnvironment(index.document, row);
@@ -70214,7 +71211,7 @@ function tryMemberTypeInfo(document, rawMember, env) {
 function isAggregateTypeInfo(typeInfo) {
   return typeInfo.type === 7 /* Class */ || typeInfo.type === 22 /* Interface */ || typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */;
 }
-function isStringRecord3(value) {
+function isStringRecord4(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return false;
   }
@@ -70636,7 +71633,7 @@ function createStoredValuePlacementTraversal(args, trackReferences = false) {
       if (isMemberClassBase(member)) {
         const classId = value.classId ?? member.classId;
         appendPlacement(mutablePlacementsByClassId, classId, placement);
-        if (!isLiteralValueContent(value) || !isStringRecord4(value.value)) {
+        if (!isLiteralValueContent(value) || !isStringRecord5(value.value)) {
           continue;
         }
         const settledChildrenBySchemaKey = /* @__PURE__ */ new Map();
@@ -70682,7 +71679,7 @@ function createStoredValuePlacementTraversal(args, trackReferences = false) {
       const entryMember = membersById.get(member.entryMemberId);
       if (entryMember === void 0) continue;
       if (isMemberDictionaryBase(member)) {
-        if (!isStringRecord4(value.value)) continue;
+        if (!isStringRecord5(value.value)) continue;
         for (const [key, childValueId2] of Object.entries(value.value)) {
           queue.push({
             memberId: entryMember.id,
@@ -70891,7 +71888,7 @@ function appendPlacement(index, key, placement) {
     placements.push(placement);
   }
 }
-function isStringRecord4(value) {
+function isStringRecord5(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
@@ -89415,6 +90412,20 @@ function compileNSGetter(code, ctx) {
     ctx.source
   );
 }
+function compileNSInferredExpressionGetter(code, ctx) {
+  const compiled = compileStrict(
+    code,
+    createContext(ctx, {
+      scriptKind: "getter",
+      dialogueContext: ctx.dialogueContext
+    }),
+    ctx.source,
+    true
+  );
+  if (!isNSGetter(compiled))
+    throw new Error("Expression compiler did not produce a getter.");
+  return compiled;
+}
 function compileNSVoidBody(code, ctx) {
   const context = createContext(ctx, {
     scriptKind: "action",
@@ -89513,9 +90524,10 @@ function withInitializerSourcePosition(error) {
     error.unit
   );
 }
-function compileStrict(code, context, sourceInfo) {
+function compileStrict(code, context, sourceInfo, inferExpressionReturnType = false) {
   const source = sourceInfo?.code === code ? sourceInfo.source : void 0;
   const cacheKey = JSON.stringify({
+    inferExpressionReturnType,
     code,
     source,
     projectIdentity: compilationProjectIdentity(context.project),
@@ -89548,7 +90560,11 @@ function compileStrict(code, context, sourceInfo) {
       text: code
     },
     context,
-    { projectIndex: compilationProjectIndex(context.project), source }
+    {
+      projectIndex: compilationProjectIndex(context.project),
+      source,
+      inferExpressionReturnType
+    }
   );
   if (result.diagnostics.length) {
     const error = result.diagnostics[0];
@@ -89619,6 +90635,7 @@ var init_compile = __esm({
   "../src/database/neoscript/compile.ts"() {
     "use strict";
     init_runtime_source();
+    init_neoscript_guards();
     init_compiler();
     init_strict_compile_error();
     init_project();
@@ -90047,7 +91064,7 @@ function createTypedValueNormalizer(reader, document, childrenByContainerId, par
         } else {
           value = normalizeLiteral(row.value);
         }
-      } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord5(row.value)) {
+      } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord6(row.value)) {
         const entries = /* @__PURE__ */ Object.create(null);
         for (const [key, childId] of Object.entries(row.value)) {
           entries[key] = normalizeTypedRow(
@@ -90128,7 +91145,7 @@ function createTypedValueNormalizer(reader, document, childrenByContainerId, par
     return typeof row.instanceConstructorId === "string" || Object.keys(constructorArgs).length > 0;
   }
   const normalizeClassValue = (row, typeInfo, env) => {
-    if (!isStringRecord5(row.value)) return normalizeLiteral(row.value);
+    if (!isStringRecord6(row.value)) return normalizeLiteral(row.value);
     const effectiveClassId = row.classId ?? (typeInfo.type === 7 /* Class */ ? typeInfo.classId : void 0);
     if (effectiveClassId === void 0) return normalizeLiteral(row.value);
     const merged = mergeInstanceSurfaceSchema(
@@ -90198,7 +91215,7 @@ function createTypedValueNormalizer(reader, document, childrenByContainerId, par
   }
   return { normalizeConstructorArgs, normalizeTypedRow };
 }
-function isStringRecord5(value) {
+function isStringRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
 function isAggregateTypeInfo2(type) {
@@ -90448,7 +91465,7 @@ var init_effective_value_reader = __esm({
         const row = this.rawRow(valueId);
         if (row === void 0) return void 0;
         const classId = row.classId ?? (typeInfo?.type === 7 /* Class */ ? typeInfo.classId : void 0) ?? (isMemberClassBase(placement) ? placement.classId : void 0);
-        if (classId === void 0 || row.value === null || !isStringRecord5(row.value))
+        if (classId === void 0 || row.value === null || !isStringRecord6(row.value))
           return row;
         if (this.resolvedRoots.has(valueId)) return row;
         if (this.mode(valueId) === "partial") return row;
@@ -90818,6 +91835,7 @@ __export(compiler_adapter_exports, {
   compileNSConstructor: () => compileNSConstructor,
   compileNSFunction: () => compileNSFunction,
   compileNSGetter: () => compileNSGetter,
+  compileNSInferredExpressionGetter: () => compileNSInferredExpressionGetter,
   compileNSInitializer: () => compileNSInitializer,
   compileNSSetter: () => compileNSSetter,
   compileNSVoidBody: () => compileNSVoidBody,
@@ -93967,251 +94985,6 @@ var init_localized_text_create_envelope = __esm({
   }
 });
 
-// ../src/database/neo-script-derived-bodies.ts
-function cloneAndStripClientDerivedBodies(change) {
-  if (change.operation === "delete" || change.nextData === void 0) {
-    return { ...change };
-  }
-  return {
-    ...change,
-    nextData: stripClientDerivedBodies(change.recordKind, change.nextData)
-  };
-}
-function stripClientDerivedBodies(recordKind, nextData) {
-  const record7 = asRecord2(nextData);
-  return record7 === null ? nextData : strippedClone(recordKind, record7);
-}
-function hasPendingNeoScriptDerivation(recordKind, data) {
-  const record7 = asRecord2(data);
-  if (record7 === null) return false;
-  return collectDerivedBodySites(recordKind, record7).some(
-    (site) => site.authored && !(site.key in site.container)
-  );
-}
-function strippedClone(recordKind, record7) {
-  const next = structuredClone(record7);
-  const container = asRecord2(next);
-  if (container === null) return next;
-  for (const site of collectDerivedBodySites(recordKind, container)) {
-    delete site.container[site.key];
-  }
-  return next;
-}
-function collectDerivedBodySites(recordKind, record7) {
-  const sites = [];
-  if (recordKind === "migration") {
-    sites.push({
-      container: record7,
-      key: "action",
-      authored: typeof record7.code === "string"
-    });
-    return sites;
-  }
-  if (recordKind === "dialogue-group") {
-    collectConditionSites(record7.conditions, sites);
-    return sites;
-  }
-  if (recordKind === "dialogue-node") {
-    collectDialogueNodeSites(record7, sites);
-    return sites;
-  }
-  if (recordKind === "constructor") {
-    sites.push({ container: record7, key: "action", authored: true });
-    sites.push({
-      container: record7,
-      key: "compiledBaseArguments",
-      authored: false
-    });
-    sites.push({
-      container: record7,
-      key: "compiledBaseInitializerFields",
-      authored: false
-    });
-    return sites;
-  }
-  if (recordKind === "value") {
-    collectValueBodySites(record7, sites);
-    return sites;
-  }
-  if (recordKind !== "member") return sites;
-  if (record7.kind === 10 /* NSProperty */) {
-    sites.push({
-      container: record7,
-      key: "getter",
-      authored: typeof record7.code === "string"
-    });
-    sites.push({
-      container: record7,
-      key: "setter",
-      authored: typeof record7.setterCode === "string"
-    });
-  }
-  if (record7.kind === 23 /* NSFunction */) {
-    sites.push({
-      container: record7,
-      key: "action",
-      authored: typeof record7.code === "string"
-    });
-  }
-  if (record7.kind === 25 /* NSDelegate */) {
-    collectDelegateClosureSite(asRecord2(record7.defaultValue), sites, false);
-  }
-  collectInitializerSite(asRecord2(record7.defaultValue), sites);
-  return sites;
-}
-function collectValueBodySites(record7, sites) {
-  collectInitializerSite(record7, sites);
-  collectDelegateClosureSite(record7, sites, true);
-  collectInlineDelegateArgumentSites(record7, sites);
-  for (const container of [record7.value, record7.constructorArgs]) {
-    if (container === null || typeof container !== "object") continue;
-    for (const candidate of Object.values(container)) {
-      if (!isPackedValueEnvelope(candidate)) continue;
-      const child2 = asRecord2(candidate[PACKED_VALUE_ENTRY_KEY]);
-      if (child2 !== null) collectValueBodySites(child2, sites);
-    }
-  }
-}
-function collectDialogueNodeSites(node, sites) {
-  collectConditionSites(node.conditions, sites);
-  collectTextVariableSites(node.variables, sites);
-  if (Array.isArray(node.actions)) {
-    for (const actionValue2 of node.actions) {
-      const logic = asRecord2(asRecord2(actionValue2)?.logic);
-      if (logic === null) continue;
-      if (logic.type !== 1 /* Code */) continue;
-      if (typeof logic.code !== "string") continue;
-      sites.push({ container: logic, key: "action", authored: true });
-    }
-  }
-  if (Array.isArray(node.outcomes)) {
-    for (const outcomeValue of node.outcomes) {
-      collectConditionSites(asRecord2(outcomeValue)?.conditions, sites);
-    }
-  }
-  const options = asRecord2(node.optionSettings)?.options;
-  if (!Array.isArray(options)) return;
-  for (const optionValue of options) {
-    const option = asRecord2(optionValue);
-    if (option === null) continue;
-    collectTextVariableSites(option.variables, sites);
-    const settings = asRecord2(option.settings);
-    if (settings === null) continue;
-    collectConditionSites(settings.conditions, sites);
-    collectConditionSites(settings.selectableConditions, sites);
-  }
-}
-function collectConditionSites(value, sites) {
-  if (!Array.isArray(value)) return;
-  for (const conditionValue of value) {
-    const condition = asRecord2(conditionValue);
-    if (condition === null) continue;
-    if (condition.type !== 1 /* Code */) continue;
-    if (typeof condition.code !== "string") continue;
-    sites.push({ container: condition, key: "getter", authored: true });
-  }
-}
-function collectTextVariableSites(value, sites) {
-  const variables = asRecord2(value);
-  if (variables === null) return;
-  for (const variableValue of Object.values(variables)) {
-    const variable2 = asRecord2(variableValue);
-    if (variable2 === null) continue;
-    sites.push({ container: variable2, key: "getter", authored: true });
-  }
-}
-function collectDelegateClosureSite(container, sites, authored) {
-  const delegate = asRecord2(container?.value);
-  if (delegate === null) return;
-  if (typeof delegate.code !== "string") return;
-  sites.push({ container: delegate, key: "action", authored });
-}
-function collectInlineDelegateArgumentSites(record7, sites) {
-  const constructorArgs = asRecord2(record7.constructorArgs);
-  if (constructorArgs === null) return;
-  for (const argument2 of Object.values(constructorArgs)) {
-    const closure = asRecord2(argument2);
-    if (closure === null) continue;
-    if (typeof closure.code !== "string") continue;
-    sites.push({ container: closure, key: "action", authored: true });
-  }
-}
-function collectInitializerSite(container, sites) {
-  const init = asRecord2(container?.init);
-  if (init === null) return;
-  sites.push({ container: init, key: "compiled", authored: true });
-}
-function stripDerivedBodies(member) {
-  return strippedClone("member", member);
-}
-function stripConstructorDerivedBodies(constructorRecord) {
-  return strippedClone("constructor", constructorRecord);
-}
-function stripMigrationAction(migration) {
-  return strippedClone("migration", migration);
-}
-function stampUILogicBody(logic, bodyKey) {
-  if (logic?.type !== 0 /* UI */) return false;
-  const body = asRecord2(logic[bodyKey]);
-  if (body === null) return false;
-  if (body.compilerRevision === NEOSCRIPT_COMPILER_REVISION) return false;
-  body.compilerRevision = NEOSCRIPT_COMPILER_REVISION;
-  return true;
-}
-function stampUILogicBodies(recordKind, data) {
-  const record7 = asRecord2(data);
-  if (record7 === null) return false;
-  if (recordKind === "dialogue-group") {
-    return stampConditionList(record7.conditions);
-  }
-  if (recordKind !== "dialogue-node") return false;
-  let changed = stampConditionList(record7.conditions);
-  if (Array.isArray(record7.actions)) {
-    for (const actionValue2 of record7.actions) {
-      const logic = asRecord2(asRecord2(actionValue2)?.logic);
-      changed = stampUILogicBody(logic, "action") || changed;
-    }
-  }
-  if (Array.isArray(record7.outcomes)) {
-    for (const outcomeValue of record7.outcomes) {
-      changed = stampConditionList(asRecord2(outcomeValue)?.conditions) || changed;
-    }
-  }
-  const options = asRecord2(record7.optionSettings)?.options;
-  if (Array.isArray(options)) {
-    for (const optionValue of options) {
-      const settings = asRecord2(asRecord2(optionValue)?.settings);
-      if (settings === null) continue;
-      changed = stampConditionList(settings.conditions) || changed;
-      changed = stampConditionList(settings.selectableConditions) || changed;
-    }
-  }
-  return changed;
-}
-function stampConditionList(value) {
-  if (!Array.isArray(value)) return false;
-  let changed = false;
-  for (const conditionValue of value) {
-    changed = stampUILogicBody(asRecord2(conditionValue), "getter") || changed;
-  }
-  return changed;
-}
-function asRecord2(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return null;
-  }
-  return value;
-}
-var init_neo_script_derived_bodies = __esm({
-  "../src/database/neo-script-derived-bodies.ts"() {
-    "use strict";
-    init_members();
-    init_logic_types();
-    init_strict_ir();
-    init_packed_value_encoding();
-  }
-});
-
 // ../src/database/neo-script-recompile-scope.ts
 function memberNeoScriptContractChanged(current, next) {
   return canonicalJsonStringify(neoScriptMemberContractProjection(current)) !== canonicalJsonStringify(neoScriptMemberContractProjection(next));
@@ -101812,14 +102585,14 @@ function findParentValues(valueId, values) {
       }
       continue;
     }
-    if (!isStringRecord6(value.value)) continue;
+    if (!isStringRecord7(value.value)) continue;
     for (const [key, childValueId2] of Object.entries(value.value)) {
       if (childValueId2 === valueId) parents.push({ value, key });
     }
   }
   return parents;
 }
-function isStringRecord6(value) {
+function isStringRecord7(value) {
   if (typeof value !== "object") return false;
   if (value === null) return false;
   if (Array.isArray(value)) return false;
@@ -101996,9 +102769,16 @@ function compileDialogueLogicWithProjectData(request, projectData) {
       node: request.node,
       returnTypeInfo: sourceBacked ? request.textVariable.typeInfo : { type: 3 /* String */, required: true }
     });
+    if (!sourceBacked)
+      return {
+        target: 2 /* TextVariable */,
+        getter: compileTextVariableGetter(ctx2, request.textVariable)
+      };
+    const getter = request.textVariable.sourceInline ? compileNSInferredExpressionGetter(request.code, ctx2) : compileNSGetter(request.code, ctx2);
     return {
       target: 2 /* TextVariable */,
-      getter: sourceBacked ? stringifyCompiledTextGetter(compileNSGetter(request.code, ctx2)) : compileTextVariableGetter(ctx2, request.textVariable)
+      getter: stringifyCompiledTextGetter(getter),
+      sourceTypeInfo: getter.typeInfo
     };
   }
   if (request.dialogueGroup) {
@@ -102771,7 +103551,8 @@ function recompileDialogueNode(args) {
         (message) => ({
           target: 1 /* Action */,
           action: makeThrowBody(message, VOID_ACTION_TYPE_INFO)
-        })
+        }),
+        typeof logic.sourceFunctionId === "string" ? { id: logic.sourceFunctionId, code: logic.code } : void 0
       );
       if (!compiled.ok) continue;
       const response = compiled.value;
@@ -102861,7 +103642,8 @@ function recompileConditionList(value, context) {
       (message) => ({
         target: 0 /* Condition */,
         getter: makeThrowBody(message, BOOL_TYPE_INFO)
-      })
+      }),
+      typeof condition.sourceFunctionId === "string" ? { id: condition.sourceFunctionId, code: condition.code } : void 0
     );
     if (!compiled.ok) continue;
     const response = compiled.value;
@@ -102890,6 +103672,7 @@ function recompileTextVariables(value, context) {
           dialogue: context.dialogue,
           node: context.node,
           textVariable: {
+            sourceInline: variable2.sourceInline === true,
             nodeId: context.nodeId,
             optionId: context.optionId,
             pointer: variable2.pointer,
@@ -102907,7 +103690,14 @@ function recompileTextVariables(value, context) {
       (message) => ({
         target: 2 /* TextVariable */,
         getter: makeThrowBody(message, STRING_TYPE_INFO)
-      })
+      }),
+      {
+        id: variable2.sourceInline === true ? variableId : requiredString2(
+          variable2.sourceFunctionId ?? variableId,
+          "text source function id"
+        ),
+        code: typeof variable2.code === "string" ? variable2.code : ""
+      }
     );
     if (!compiled.ok) continue;
     const response = compiled.value;
@@ -102915,6 +103705,7 @@ function recompileTextVariables(value, context) {
       throw new Error("Dialogue text-variable compilation returned code IR.");
     }
     variable2.getter = response.getter;
+    if (response.sourceTypeInfo) variable2.typeInfo = response.sourceTypeInfo;
     changed = true;
   }
   return changed;
@@ -102933,7 +103724,7 @@ function buildDialogueContext(dialogue, nodes) {
     }
   };
 }
-function compileSourceUnit(label, compile, onSourceRejection, compileErrorFallback) {
+function compileSourceUnit(label, compile, onSourceRejection, compileErrorFallback, body) {
   try {
     return { ok: true, value: compile() };
   } catch (error) {
@@ -102945,6 +103736,8 @@ function compileSourceUnit(label, compile, onSourceRejection, compileErrorFallba
       }
       return { ok: false };
     }
+    if (error instanceof CompileError && body)
+      throw new SourceBodyCompileError(label, body.id, body.code, error);
     throw new Error(`Cannot recompile ${label}: ${message}`, { cause: error });
   }
 }
@@ -102986,7 +103779,7 @@ function asObject(value) {
 function cloneObject(value) {
   return structuredClone(value);
 }
-var VOID_ACTION_TYPE_INFO, BOOL_TYPE_INFO, STRING_TYPE_INFO;
+var SourceBodyCompileError, VOID_ACTION_TYPE_INFO, BOOL_TYPE_INFO, STRING_TYPE_INFO;
 var init_general_function_call_ir_source_recompile = __esm({
   "../src/database/general-function-call-ir-source-recompile.ts"() {
     "use strict";
@@ -103006,6 +103799,22 @@ var init_general_function_call_ir_source_recompile = __esm({
     init_dialogue_node_index();
     init_strict_ir();
     init_neo_script_derived_bodies();
+    SourceBodyCompileError = class extends Error {
+      constructor(sourceLabel, bodyId, code, compileError) {
+        super(`Cannot recompile ${sourceLabel}: ${compileError.message}`, {
+          cause: compileError
+        });
+        this.sourceLabel = sourceLabel;
+        this.bodyId = bodyId;
+        this.code = code;
+        this.compileError = compileError;
+        this.name = "SourceBodyCompileError";
+      }
+      sourceLabel;
+      bodyId;
+      code;
+      compileError;
+    };
     VOID_ACTION_TYPE_INFO = {
       type: 0 /* Null */,
       required: true
@@ -104642,9 +105451,9 @@ function assertNumberRange(member, value, path) {
   }
 }
 function stringRecord3(value) {
-  return isStringRecord7(value) ? value : null;
+  return isStringRecord8(value) ? value : null;
 }
-function isStringRecord7(value) {
+function isStringRecord8(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
@@ -117805,7 +118614,7 @@ function toWorldReferenceClassRecord(value) {
   return {
     id: id2,
     extendsClassId: nullableStringField(value, "extendsClassId"),
-    schema: isStringRecord8(value.schema) ? value.schema : void 0,
+    schema: isStringRecord9(value.schema) ? value.schema : void 0,
     system: isPlainRecord7(value.system) ? value.system : null
   };
 }
@@ -117823,7 +118632,7 @@ function worldReferenceValueClassId(value) {
   if (value === void 0) return null;
   return typeof value.classId === "string" && value.classId.length > 0 ? value.classId : null;
 }
-function isStringRecord8(value) {
+function isStringRecord9(value) {
   if (!isPlainRecord7(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
@@ -122839,7 +123648,8 @@ function builtinTextVariableMember(receiver, name) {
   }
   return null;
 }
-function lowerDialogueProjectSourcesV4(state, analysis) {
+function lowerDialogueProjectSourcesV4(state, analysis, options = {}) {
+  const sourceCapture = options.sourceCapture;
   const result = [];
   const mainLocale = readMainLocale(state);
   const dialogueGroups = analysis.dialogueGroups.globals.filter(
@@ -122855,94 +123665,133 @@ function lowerDialogueProjectSourcesV4(state, analysis) {
   const sourceSchema = new SourceSchemaIndex(analysis);
   const valueSymbols = indexValueSymbols(state, analysis);
   const nodesByDialogueId = dialogueNodesByDialogueId(state);
+  let referenceTypeIndex;
+  const referenceTypes = () => referenceTypeIndex ??= new ReferenceTargetTypes(
+    state,
+    options.authoredValueSeeds,
+    [],
+    options.manifest
+  );
   for (const dialogue of analysis.dialogues.dialogues) {
-    const dialogueId = sourceId2(dialogue, "dialogue", dialogue.name);
-    const baseDialogue = baseData2(state, "dialogue", dialogueId);
-    const nodesById = nodesByDialogueId.get(dialogueId) ?? /* @__PURE__ */ new Map();
-    const memberIdsByName = new Map(
-      dialogue.members.map((member) => [
-        member.name,
-        sourceId2(member, "dialogue-node", member.name)
-      ])
-    );
-    const functionsByName = new Map(
-      dialogue.functions.map((fn) => [fn.name, fn])
-    );
-    const context = {
-      state,
-      dialogue,
-      dialogueId,
-      baseDialogue,
-      nodesById,
-      memberIdsByName,
-      functionsByName,
-      existingLogic: indexExistingLogic(nodesById.values()),
-      mainLocale,
-      dialogueGroupIds,
-      lookupDialogueGroupIds,
-      priorityGroupsById,
-      valueSymbols,
-      sourceSchema,
-      dialogueBindingTypes: new Map(
-        dialogue.bindings.map((binding) => [binding.name, binding.type])
-      ),
-      dialogueLinks: Array.isArray(baseDialogue.linkedValues) ? baseDialogue.linkedValues.filter(isObjectRecord2) : [],
-      dialoguePrimaryValueId: nullableString4(baseDialogue.primaryLinkedValueId),
-      sourcePrimaryAlias: primaryBindingName(dialogue.bindings)
-    };
-    const trigger = dialogue.members.find(
-      (member) => member.graphType === "Trigger"
-    );
-    if (!trigger)
-      throw new Error(`Dialogue ${dialogue.name} requires Trigger.`);
-    const settings = annotationArguments(dialogue.annotations, "settings");
-    const linked = lowerBindings(
-      context,
-      dialogue.bindings,
-      baseDialogue.linkedValues
-    );
-    const primary = primaryValueId(dialogue.bindings, linked);
-    const graphContext = {
-      ...context,
-      dialogueLinks: linked,
-      dialoguePrimaryValueId: primary
-    };
-    const description = lowerDialogueDescription(
-      context,
-      settings.get("description"),
-      result
-    );
-    result.push(
-      reconstructed2(
-        "dialogue",
+    try {
+      const dialogueId = sourceId2(dialogue, "dialogue", dialogue.name);
+      const baseDialogue = baseData2(state, "dialogue", dialogueId);
+      const nodesById = nodesByDialogueId.get(dialogueId) ?? /* @__PURE__ */ new Map();
+      const memberIdsByName = new Map(
+        dialogue.members.map((member) => [
+          member.name,
+          sourceId2(member, "dialogue-node", member.name)
+        ])
+      );
+      const functionsByName = new Map(
+        dialogue.functions.map((fn) => [fn.name, fn])
+      );
+      const context = {
+        sourceCapture,
+        referenceTypes,
+        state,
+        dialogue,
         dialogueId,
-        {
-          ...baseDialogue,
-          id: dialogueId,
-          sourceName: dialogue.name,
-          name: literalString(settings.get("name")) ?? stringOr(baseDialogue.name, dialogue.name),
-          description,
-          settings: {
-            ...isObjectRecord2(baseDialogue.settings) ? baseDialogue.settings : {},
-            defaultSaveOptionChoices: literalBoolean(settings.get("saveOptionChoices")) ?? booleanOr(
-              isObjectRecord2(baseDialogue.settings) ? baseDialogue.settings.defaultSaveOptionChoices : void 0,
-              true
-            )
+        baseDialogue,
+        nodesById,
+        memberIdsByName,
+        functionsByName,
+        existingLogic: indexExistingLogic(nodesById.values()),
+        mainLocale,
+        dialogueGroupIds,
+        lookupDialogueGroupIds,
+        priorityGroupsById,
+        valueSymbols,
+        sourceSchema,
+        dialogueBindingTypes: new Map(
+          dialogue.bindings.map((binding) => [binding.name, binding.type])
+        ),
+        dialogueLinks: Array.isArray(baseDialogue.linkedValues) ? baseDialogue.linkedValues.filter(isObjectRecord2) : [],
+        dialoguePrimaryValueId: nullableString4(
+          baseDialogue.primaryLinkedValueId
+        ),
+        sourcePrimaryAlias: primaryBindingName(dialogue.bindings)
+      };
+      const trigger = dialogue.members.find(
+        (member) => member.graphType === "Trigger"
+      );
+      if (!trigger)
+        throw new Error(`Dialogue ${dialogue.name} requires Trigger.`);
+      const settings = annotationArguments(dialogue.annotations, "settings");
+      const linked = lowerBindings(
+        context,
+        dialogue.bindings,
+        baseDialogue.linkedValues
+      );
+      const primary = primaryValueId(dialogue.bindings, linked);
+      const graphContext = {
+        ...context,
+        dialogueLinks: linked,
+        dialoguePrimaryValueId: primary
+      };
+      const description = lowerDialogueDescription(
+        context,
+        settings.get("description"),
+        result
+      );
+      result.push(
+        reconstructed2(
+          "dialogue",
+          dialogueId,
+          {
+            ...baseDialogue,
+            id: dialogueId,
+            sourceName: dialogue.name,
+            name: literalString(settings.get("name")) ?? stringOr(baseDialogue.name, dialogue.name),
+            description,
+            settings: {
+              ...isObjectRecord2(baseDialogue.settings) ? baseDialogue.settings : {},
+              defaultSaveOptionChoices: literalBoolean(settings.get("saveOptionChoices")) ?? booleanOr(
+                isObjectRecord2(baseDialogue.settings) ? baseDialogue.settings.defaultSaveOptionChoices : void 0,
+                true
+              )
+            },
+            linkedValues: linked,
+            primaryLinkedValueId: primary,
+            triggerNodeId: sourceId2(trigger, "dialogue-node", trigger.name)
           },
-          linkedValues: linked,
-          primaryLinkedValueId: primary,
-          triggerNodeId: sourceId2(trigger, "dialogue-node", trigger.name)
-        },
-        dialogue
-      )
-    );
-    dialogue.members.forEach((member, index) => {
-      const lowered = lowerGraphMember(graphContext, member, index);
-      result.push(...lowered);
-    });
+          dialogue
+        )
+      );
+      dialogue.members.forEach((member, index) => {
+        try {
+          result.push(
+            ...lowerGraphMember(
+              {
+                ...graphContext,
+                sourceOwnerName: `${dialogue.name}.${member.name}`
+              },
+              member,
+              index
+            )
+          );
+        } catch (error) {
+          throw dialogueSourceError(error, member.source);
+        }
+      });
+    } catch (error) {
+      throw dialogueSourceError(error, dialogue.source);
+    }
   }
   return result;
 }
+function dialogueSourceError(error, source) {
+  if (error instanceof SchemaSourceError) return error;
+  return new SchemaSourceError(
+    error instanceof Error ? error.message : String(error),
+    source.uri,
+    source.range.start.line + 1,
+    source.range.start.character + 1,
+    "neoflow-lowering",
+    "error",
+    source.range
+  );
+}
 function lowerGraphMember(context, member, index) {
   const id2 = sourceId2(member, "dialogue-node", member.name);
   const base = context.nodesById.get(id2) ?? {};
@@ -123061,7 +123910,8 @@ function lowerTextNode(context, member, id2, base, common, destination) {
     nullableString4(common.primaryLinkedValueId) ?? context.dialoguePrimaryValueId,
     `node:${id2}`,
     dialogueNodeLocalizedTextLink(id2),
-    member
+    member,
+    member.content?.proseSources?.[0]
   );
   const children = member.content?.children.filter((child2) => child2.graphType === "Option") ?? [];
   const baseOptionSettings = isObjectRecord2(base.optionSettings) ? base.optionSettings : {};
@@ -123087,7 +123937,8 @@ function lowerTextNode(context, member, id2, base, common, destination) {
       nullableString4(common.primaryLinkedValueId) ?? context.dialoguePrimaryValueId,
       `option:${optionId}`,
       dialogueChoiceLocalizedTextLink(id2, optionId),
-      child2
+      child2,
+      child2.content?.proseSources?.[0]
     );
     if (optionText.textRecord) textRecords.push(optionText.textRecord);
     const priorSettings = isObjectRecord2(optionBase.settings) ? optionBase.settings : {};
@@ -123285,6 +124136,14 @@ function lowerConditionUses(context, expression, owner) {
         `${owner} condition ${use.name} must resolve to a zero-argument bool function.`
       );
     }
+    context.sourceCapture?.bodies.set(
+      sourceId2(fn, "dialogue-function", fn.name),
+      {
+        name: `${context.dialogue.name}.${fn.name}`,
+        location: fn.bodySource ?? fn.source,
+        thisAlias: context.sourcePrimaryAlias ?? void 0
+      }
+    );
     const prior = context.existingLogic.conditionsByUseId.get(id2);
     const body = functionCode(fn);
     if (body === null) {
@@ -123359,6 +124218,14 @@ function conditionProjectionMatches(context, prior, body) {
   return false;
 }
 function lowerActionLogic(context, prior, fn, fallbackCode, inline, useId, uiResolver) {
+  context.sourceCapture?.bodies.set(
+    inline ? useId : sourceId2(fn, "dialogue-function", fn.name),
+    {
+      name: inline ? `${context.sourceOwnerName} action` : `${context.dialogue.name}.${fn.name}`,
+      location: fn.bodySource ?? fn.source,
+      thisAlias: context.sourcePrimaryAlias ?? void 0
+    }
+  );
   const code = functionCode(fn) ?? fallbackCode;
   if (prior?.type === 0) {
     const projected = uiActionSource(prior.action, uiResolver);
@@ -123385,7 +124252,7 @@ function lowerActionLogic(context, prior, fn, fallbackCode, inline, useId, uiRes
     action: isObjectRecord2(prior?.action) ? prior.action : placeholderVoidAction()
   };
 }
-function lowerProse(context, rawProse, baseTextId, baseVariables, baseLinks, bindingTypes, primaryValueId2, owner, textLink, source) {
+function lowerProse(context, rawProse, baseTextId, baseVariables, baseLinks, bindingTypes, primaryValueId2, owner, textLink, source, proseSource) {
   const textId = baseTextId ?? pendingId("localized-text", source.source.uri, owner, 0, "text");
   const baseText = baseData2(context.state, "localized-text", textId);
   const variablesByPath = /* @__PURE__ */ new Map();
@@ -123417,8 +124284,13 @@ function lowerProse(context, rawProse, baseTextId, baseVariables, baseLinks, bin
   const main2 = isObjectRecord2(mainCandidate) ? mainCandidate : {};
   const pulledMainText = typeof main2.value === "string" ? main2.value : "";
   let ordinal = 0;
+  let expressionOrdinal = 0;
+  const rawExpressions = context.sourceCapture ? decodeProseSegments(rawProse, false).filter(
+    (segment) => segment.kind === "expression"
+  ) : [];
   const value = decodeProseSegments(rawProse).map((segment) => {
     if (segment.kind === "literal") return segment.value;
+    const rawExpression = rawExpressions[expressionOrdinal++];
     const expression = segment.value;
     const sourcePath = expression.trim();
     const missingVariableId = missingTextVariableId(sourcePath);
@@ -123451,6 +124323,30 @@ function lowerProse(context, rawProse, baseTextId, baseVariables, baseLinks, bin
     const functionName = callExpressionName(sourcePath) ?? `TextValue${ordinal + 1}`;
     const fn = callExpressionName(sourcePath) ? context.functionsByName.get(functionName) : void 0;
     const functionBody = fn ? functionCode(fn) : null;
+    const capture = context.sourceCapture;
+    if (capture) {
+      let location3 = source.source;
+      const text = capture.texts.get(location3.uri);
+      if (text !== void 0 && proseSource && rawExpression) {
+        const file = text;
+        const start = file.offsetAt(proseSource.range.start) + 3;
+        location3 = {
+          uri: location3.uri,
+          range: {
+            start: file.positionAt(start + rawExpression.start),
+            end: file.positionAt(start + rawExpression.end)
+          }
+        };
+      }
+      const bodyId = fn ? sourceId2(fn, "dialogue-function", fn.name) : variableId;
+      const effectivePrimaryAlias = typeof primaryAlias === "string" ? primaryAlias : void 0;
+      if (!capture.bodies.has(bodyId))
+        capture.bodies.set(bodyId, {
+          name: fn ? `${context.dialogue.name}.${fn.name}` : `${context.sourceOwnerName} interpolation`,
+          location: fn?.bodySource ?? fn?.source ?? location3,
+          thisAlias: fn ? context.sourcePrimaryAlias ?? void 0 : effectivePrimaryAlias
+        });
+    }
     if (prior !== void 0 && (fn === void 0 || functionBody === null)) {
       const declaredFunction = fn ?? sourceFunctionForPrior(context, prior);
       variables[variableId] = declaredFunction ? {
@@ -123490,7 +124386,7 @@ function lowerProse(context, rawProse, baseTextId, baseVariables, baseLinks, bin
       bindingTypes,
       primaryValueId2
     );
-    const sourceTypeInfo = fn ? sourceReturnTypeInfo(fn.type.name, fn.type.nullable) : directMetadata?.typeInfo ?? (isObjectRecord2(prior?.typeInfo) ? prior.typeInfo : { type: 3 /* String */, required: true });
+    const sourceTypeInfo = fn ? sourceReturnTypeInfo(fn.type.name, fn.type.nullable) : directMetadata?.typeInfo ?? (isObjectRecord2(prior?.typeInfo) ? prior.typeInfo : { type: NS_TYPE_UNKNOWN, required: true });
     variables[variableId] = {
       ...prior ?? {},
       id: variableId,
@@ -123746,12 +124642,33 @@ function lowerBindings(context, bindings, baseLinks) {
   const explicit = bindings.map((binding) => {
     if (binding.initializer === null)
       throw new Error(`Binding ${binding.name} requires an initializer.`);
-    const valueId = resolveBindingValueId(
-      context,
-      binding.initializer,
-      existing,
-      binding.name
-    );
+    let valueId;
+    try {
+      const expression = parseExpression(binding.initializer);
+      valueId = resolveBindingValueId(
+        context,
+        binding.initializer,
+        binding.name,
+        expression
+      );
+      if (expression.kind === "call" && expression.callee.kind === "ident" && expression.callee.name === "Reference") {
+        const explicit2 = expression.typeArguments?.[0];
+        if (explicit2) {
+          const name = astTypeNameV4(explicit2);
+          context.referenceTypes().assertAssignable(valueId, name, `Reference<${name}>`);
+        }
+      }
+      context.referenceTypes().assertAssignable(
+        valueId,
+        binding.type.name,
+        `Binding ${binding.name}`
+      );
+    } catch (error) {
+      throw dialogueSourceError(
+        error,
+        binding.initializerSource ?? binding.source
+      );
+    }
     const previous = existing.find(
       (link) => link.valueId === valueId || link.sourceName === binding.name
     );
@@ -123793,7 +124710,8 @@ function lowerNodeBindings(context, content, baseLinks) {
     (binding) => ({
       id: null,
       state: "pending",
-      source: context.dialogue.source,
+      source: binding.source ?? context.dialogue.source,
+      initializerSource: binding.source,
       kind: "field",
       name: binding.name,
       type: parseManifestTypeText(binding.type),
@@ -123870,31 +124788,33 @@ function parseManifestTypeText(source) {
   }
   return result;
 }
-function resolveBindingValueId(context, initializer, existing, sourceName) {
-  const idMatch = initializer.match(
-    /\bReference(?:<[^>]+>)?\s*\(\s*(?:id\s*:\s*)?("(?:[^"\\]|\\.)*")\s*\)/
-  );
-  if (idMatch?.[1]) return JSON.parse(idMatch[1]);
+function resolveBindingValueId(context, initializer, sourceName, expression) {
+  if (expression.kind === "call" && expression.callee.kind === "ident" && expression.callee.name === "Reference") {
+    const idIndex = expression.argumentNames?.indexOf("id") ?? -1;
+    if (idIndex >= 0) {
+      const id2 = expression.args[idIndex];
+      if (id2?.kind === "litString") return id2.value;
+    }
+    if (expression.argumentNames?.includes("key"))
+      throw new Error(
+        `Binding ${sourceName}: Reference(key:) requires a lookup field's collection context. Use Reference<T>(id: "...").`
+      );
+  }
   const direct = directValueSymbol(initializer);
   if (direct !== null) {
     const symbol = context.valueSymbols.get(direct);
     if (symbol !== void 0) return symbol.valueId;
   }
-  const byName = existing.find((link) => link.sourceName === sourceName);
-  if (typeof byName?.valueId === "string") return byName.valueId;
-  if (existing.length === 1 && typeof existing[0]?.valueId === "string") {
-    return existing[0].valueId;
-  }
   throw new Error(
     `Binding ${sourceName} initializer ${JSON.stringify(initializer)} cannot be resolved to a stable value. Use Reference<T>(id: "...").`
   );
 }
 function directValueSymbol(initializer) {
   const trimmed = initializer.trim();
-  if (/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+$/.test(trimmed)) {
+  if (/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(trimmed)) {
     return trimmed;
   }
-  const reference2 = /^Reference(?:<[^>]+>)?\s*\(\s*([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+)\s*\)$/.exec(
+  const reference2 = /^Reference(?:<[^>]+>)?\s*\(\s*([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s*\)$/.exec(
     trimmed
   );
   return reference2?.[1] ?? null;
@@ -124041,13 +124961,18 @@ function proseExpressions(raw) {
   );
 }
 function lowerDialogueGroupSettings(context, member, base) {
+  const groupSource = member.arguments.find((argument2) => argument2.name === "group")?.source ?? member.source;
+  const prioritySource = member.arguments.find((argument2) => argument2.name === "priority")?.source ?? groupSource;
   const expression = constructorExpression(member.arguments, "group");
   if (expression === null) return null;
   const old = isObjectRecord2(base.dialogueGroupSettings) ? base.dialogueGroupSettings : {};
   const referencedGroupId = referenceId2(expression, "DialogueGroup");
   if (referencedGroupId !== null) {
     if (![...context.dialogueGroupIds.values()].includes(referencedGroupId)) {
-      throw new Error(`Unknown dialogue group ${referencedGroupId}.`);
+      throw dialogueSourceError(
+        `Unknown dialogue group ${referencedGroupId}.`,
+        groupSource
+      );
     }
     const group2 = baseData2(context.state, "dialogue-group", referencedGroupId);
     const priorityGroupId2 = nullableString4(group2.priorityGroupIdOverride) ?? defaultPriorityGroupId(context.state);
@@ -124059,14 +124984,18 @@ function lowerDialogueGroupSettings(context, member, base) {
     );
     const priorityOptionId = priorityExpression === null ? null : referenceId2(priorityExpression, "PriorityOption");
     if (priorityExpression !== null && priorityOptionId === null) {
-      throw new Error(
-        'Trigger priority must be authored as Reference<PriorityOption>(id: "...").'
+      throw dialogueSourceError(
+        'Trigger priority must be authored as Reference<PriorityOption>(id: "...").',
+        prioritySource
       );
     }
     if (priorityOptionId !== null && !options2.some(
       (candidate) => isObjectRecord2(candidate) && candidate.id === priorityOptionId
     )) {
-      throw new Error(`Unknown priority option ${priorityOptionId}.`);
+      throw dialogueSourceError(
+        `Unknown priority option ${priorityOptionId}.`,
+        prioritySource
+      );
     }
     return {
       ...old,
@@ -124081,12 +125010,17 @@ function lowerDialogueGroupSettings(context, member, base) {
   }
   const [groupName, optionName] = expression.split(".");
   if (!groupName || !optionName) {
-    throw new Error(
-      `Trigger group must be authored as DialogueGroup.PriorityOption.`
+    throw dialogueSourceError(
+      `Trigger group must be authored as DialogueGroup.PriorityOption.`,
+      groupSource
     );
   }
   const groupId = context.dialogueGroupIds.get(groupName);
-  if (!groupId) throw new Error(`Unknown dialogue group ${groupName}.`);
+  if (!groupId)
+    throw dialogueSourceError(
+      `Unknown dialogue group ${groupName}.`,
+      groupSource
+    );
   const group = baseData2(context.state, "dialogue-group", groupId);
   const priorityGroupId = nullableString4(group.priorityGroupIdOverride) ?? defaultPriorityGroupId(context.state);
   const priority = priorityGroupId ? context.priorityGroupsById.get(priorityGroupId) : void 0;
@@ -124095,7 +125029,10 @@ function lowerDialogueGroupSettings(context, member, base) {
     (candidate) => isObjectRecord2(candidate) && candidate.name === optionName
   );
   if (!isObjectRecord2(option) || typeof option.id !== "string") {
-    throw new Error(`Unknown priority option ${expression}.`);
+    throw dialogueSourceError(
+      `Unknown priority option ${expression}.`,
+      groupSource
+    );
   }
   return {
     ...old,
@@ -124109,8 +125046,29 @@ function lowerDialogueGroupSettings(context, member, base) {
   };
 }
 function lookupValueSettings(context, groupId, old) {
-  if (context.lookupDialogueGroupIds.has(groupId))
-    return { lookupValueId: context.dialoguePrimaryValueId };
+  if (context.lookupDialogueGroupIds.has(groupId)) {
+    const valueId = context.dialoguePrimaryValueId;
+    const group = baseData2(context.state, "dialogue-group", groupId);
+    const typeName = typeof group.collectionMemberId === "string" ? context.referenceTypes().collectionEntryTypeName(group.collectionMemberId) : null;
+    if (valueId !== null && typeName !== null) {
+      const primary = context.dialogue.bindings.find(
+        (binding) => hasAnnotation3(binding.annotations, "primary")
+      );
+      try {
+        context.referenceTypes().assertAssignable(
+          valueId,
+          typeName,
+          `Lookup group ${String(group.name ?? groupId)}`
+        );
+      } catch (error) {
+        throw dialogueSourceError(
+          error,
+          primary?.initializerSource ?? primary?.source ?? context.dialogue.source
+        );
+      }
+    }
+    return { lookupValueId: valueId };
+  }
   return old.lookupValueId == null ? {} : { lookupValueId: null };
 }
 function referenceId2(expression, typeName) {
@@ -124190,8 +125148,8 @@ function decodeProse(raw) {
   if (indent2.length === 0) return value;
   return value.split("\n").map((line) => line.startsWith(indent2) ? line.slice(indent2.length) : line).join("\n");
 }
-function decodeProseSegments(raw) {
-  const value = decodeProse(raw);
+function decodeProseSegments(raw, decode2 = true) {
+  const value = decode2 ? decodeProse(raw) : raw.slice(3, -3);
   const result = [];
   let literal3 = "";
   const flushLiteral = () => {
@@ -124231,7 +125189,12 @@ function decodeProseSegments(raw) {
     if (expression.length === 0) {
       throw new Error("NeoFlow prose interpolation cannot be empty.");
     }
-    result.push({ kind: "expression", value: expression });
+    result.push({
+      kind: "expression",
+      value: expression,
+      start: index + 1,
+      end
+    });
     index = end;
   }
   flushLiteral();
@@ -124524,6 +125487,22 @@ function indexValueSymbols(state, analysis) {
       });
     }
   }
+  const locals = new LocalValueBindingsV4(
+    analysis.values.globals,
+    analysis.schema.enums.map((entry) => entry.name),
+    staticMembersInitializedByName(analysis)
+  );
+  for (const declaration of analysis.values.globals) {
+    const target = locals.declaredTarget(declaration.name);
+    if (target === null) continue;
+    const valueId = "id" in target ? target.id : result.get(target.ownerPath)?.valueId;
+    if (valueId !== void 0)
+      result.set(declaration.name, {
+        valueId,
+        declaredTypeName: declaration.type.name,
+        declaredType: declaration.type
+      });
+  }
   return result;
 }
 function memberDeclaredTypeName(member, classes) {
@@ -124615,6 +125594,10 @@ var SourceSchemaIndex;
 var init_dialogue_lower = __esm({
   "src/project-source/dialogue-lower.ts"() {
     "use strict";
+    init_local_values();
+    init_key_reference_spelling();
+    init_reference_target_types();
+    init_source_diagnostics();
     init_executable_parser();
     init_strict_ir();
     init_localization_types();
@@ -124910,226 +125893,6 @@ var init_dialogue_lower = __esm({
   }
 });
 
-// src/project-source/stored-value-placements.ts
-function storedValueRowsByIdV4(records2) {
-  const stored = /* @__PURE__ */ new Map();
-  let packed = false;
-  for (const record7 of records2) {
-    if (record7.deleted === true) continue;
-    if (record7.recordKind !== "value") continue;
-    if (!isObjectRecord2(record7.data)) continue;
-    stored.set(record7.recordId, record7.data);
-    packed ||= rowCarriesPackedValueContent(record7.data);
-  }
-  if (!packed) return stored;
-  const logical = /* @__PURE__ */ new Map();
-  for (const [valueId, row] of stored) {
-    if (!rowCarriesPackedValueContent(row)) {
-      logical.set(valueId, row);
-      continue;
-    }
-    const authoredRow = stripClientDerivedBodies("value", row);
-    if (!isMemberValue(authoredRow)) {
-      throw new PackedValueEncodingError(
-        `Stored value row "${valueId}" packs a child but is not a well-formed value row, so its packed payload cannot be expanded.`
-      );
-    }
-    const decoded = decodePackedValueRow(authoredRow);
-    logical.set(valueId, { ...decoded.row });
-    for (const child2 of decoded.children) {
-      logical.set(child2.id, { ...child2 });
-    }
-  }
-  return logical;
-}
-function buildStoredValuePlacementIndexV4(records2) {
-  const live = [...records2].filter((record7) => record7.deleted !== true);
-  const values = storedValueRowsByIdV4(live);
-  const classes = [];
-  const members = [];
-  const memberDataById = /* @__PURE__ */ new Map();
-  const constructors = /* @__PURE__ */ new Map();
-  const variantTargetClassByRootValueId = /* @__PURE__ */ new Map();
-  for (const record7 of live) {
-    if (!isObjectRecord2(record7.data)) continue;
-    if (record7.recordKind === "value") continue;
-    if (record7.recordKind === "class") {
-      classes.push({
-        id: record7.recordId,
-        ...isStringRecord9(record7.data.schema) ? { schema: record7.data.schema } : {},
-        ...typeof record7.data.extendsClassId === "string" || record7.data.extendsClassId === null ? { extendsClassId: record7.data.extendsClassId } : {},
-        ...typeof record7.data.requiredConstructorId === "string" ? { requiredConstructorId: record7.data.requiredConstructorId } : {},
-        ...Array.isArray(record7.data.genericParams) ? {
-          genericParamIds: record7.data.genericParams.flatMap(
-            (entry) => isObjectRecord2(entry) && typeof entry.id === "string" ? [entry.id] : []
-          )
-        } : {}
-      });
-    } else if (record7.recordKind === "member") {
-      memberDataById.set(record7.recordId, record7.data);
-      members.push({
-        id: record7.recordId,
-        ...record7.data.defaultValue === void 0 ? {} : { defaultValue: record7.data.defaultValue }
-      });
-    } else if (record7.recordKind === "constructor") {
-      constructors.set(record7.recordId, record7.data);
-    } else if (record7.recordKind === "variant" && typeof record7.data.valueId === "string" && typeof record7.data.classId === "string") {
-      variantTargetClassByRootValueId.set(
-        record7.data.valueId,
-        record7.data.classId
-      );
-    }
-  }
-  const classesById = new Map(
-    classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
-  const resolveSettlement = createConstructorSettlementResolver({
-    classes,
-    constructors: [...constructors].flatMap(
-      ([id2, constructor2]) => typeof constructor2.classId === "string" ? [
-        {
-          id: id2,
-          classId: constructor2.classId,
-          ...Array.isArray(constructor2.baseArguments) ? { baseArguments: constructor2.baseArguments } : {},
-          ...Array.isArray(constructor2.baseInitializerFields) ? {
-            baseInitializerFields: constructor2.baseInitializerFields
-          } : {}
-        }
-      ] : []
-    ),
-    members
-  });
-  const memberIdForSchemaKey = (classId, schemaKey) => {
-    const visited = /* @__PURE__ */ new Set();
-    let cursor = classId;
-    while (cursor !== null && !visited.has(cursor)) {
-      visited.add(cursor);
-      const schemaClass2 = classesById.get(cursor);
-      if (schemaClass2 === void 0) return null;
-      const memberId = schemaClass2.schema?.[schemaKey];
-      if (typeof memberId === "string") return memberId;
-      cursor = schemaClass2.extendsClassId ?? null;
-    }
-    return null;
-  };
-  const childrenByParentValueId = /* @__PURE__ */ new Map();
-  const placementByChildValueId = /* @__PURE__ */ new Map();
-  const add = (edge) => {
-    const children = childrenByParentValueId.get(edge.parentValueId) ?? /* @__PURE__ */ new Map();
-    if (children.has(edge.schemaKey)) return;
-    children.set(edge.schemaKey, edge);
-    childrenByParentValueId.set(edge.parentValueId, children);
-    if (!placementByChildValueId.has(edge.childValueId)) {
-      placementByChildValueId.set(edge.childValueId, edge);
-    }
-  };
-  for (const [parentValueId, value] of values) {
-    const classId = typeof value.classId === "string" ? value.classId : null;
-    const body = value.value;
-    if (isObjectRecord2(body)) {
-      for (const [schemaKey, childValueId2] of Object.entries(body)) {
-        if (typeof childValueId2 !== "string" || !values.has(childValueId2)) {
-          continue;
-        }
-        add({
-          childValueId: childValueId2,
-          memberId: classId === null ? null : memberIdForSchemaKey(classId, schemaKey),
-          parentValueId,
-          schemaKey,
-          source: "body"
-        });
-      }
-    }
-    const constructorId = value.instanceConstructorId;
-    const constructorArgs = value.constructorArgs;
-    if (classId === null || typeof constructorId !== "string" || !isObjectRecord2(constructorArgs)) {
-      continue;
-    }
-    const constructor2 = constructors.get(constructorId);
-    const parameters = constructor2?.argumentTypes;
-    if (constructor2 === void 0 || constructor2.classId !== classId || !Array.isArray(parameters)) {
-      continue;
-    }
-    for (const [index, parameter4] of parameters.entries()) {
-      if (!isObjectRecord2(parameter4) || typeof parameter4.name !== "string") {
-        continue;
-      }
-      const settled = resolveSettlement(classId, parameter4.name, constructorId);
-      if (settled === null) continue;
-      if (isObjectRecord2(body) && Object.hasOwn(body, settled.schemaKey)) {
-        continue;
-      }
-      const parameterId = constructorActionParameterId(constructor2, index);
-      const childValueId2 = constructorArgs[parameterId];
-      if (typeof childValueId2 !== "string" || !values.has(childValueId2) || !memberStoresAggregate(
-        memberDataById.get(settled.memberId),
-        value,
-        memberDataById,
-        parentValueId,
-        classesById,
-        variantTargetClassByRootValueId
-      )) {
-        continue;
-      }
-      add({
-        childValueId: childValueId2,
-        memberId: settled.memberId,
-        parentValueId,
-        schemaKey: settled.schemaKey,
-        source: "constructor"
-      });
-    }
-  }
-  return { childrenByParentValueId, placementByChildValueId };
-}
-function memberStoresAggregate(member, parent, membersById, parentValueId, classesById, variantTargetClassByRootValueId, visitedMemberIds = /* @__PURE__ */ new Set()) {
-  const kind = member?.kind;
-  if (kind === 5 /* Dictionary */ || kind === 6 /* List */ || kind === 7 /* Class */ || kind === "dictionary" || kind === "list" || kind === "class") {
-    return true;
-  }
-  if (kind !== 21 /* Generic */ && kind !== "generic") return false;
-  const memberId = typeof member?.id === "string" ? member.id : null;
-  if (memberId !== null && visitedMemberIds.has(memberId)) return false;
-  const genericParamId = member?.genericParamId;
-  const bindings = parent.genericBindings;
-  if (typeof genericParamId === "string" && isObjectRecord2(bindings)) {
-    const bindingMemberId = bindings[genericParamId];
-    if (typeof bindingMemberId === "string") {
-      return memberStoresAggregate(
-        membersById.get(bindingMemberId),
-        parent,
-        membersById,
-        parentValueId,
-        classesById,
-        variantTargetClassByRootValueId,
-        /* @__PURE__ */ new Set([
-          ...visitedMemberIds,
-          ...memberId === null ? [] : [memberId]
-        ])
-      );
-    }
-  }
-  const parentClassId = parent.classId;
-  const variantTargetClassId = variantTargetClassByRootValueId.get(parentValueId);
-  if (typeof parentClassId === "string" && typeof variantTargetClassId === "string" && classesById.get(parentClassId)?.genericParamIds?.[0] === genericParamId && classesById.has(variantTargetClassId)) {
-    return true;
-  }
-  return false;
-}
-function isStringRecord9(value) {
-  return isObjectRecord2(value) && Object.values(value).every((entry) => typeof entry === "string");
-}
-var init_stored_value_placements = __esm({
-  "src/project-source/stored-value-placements.ts"() {
-    "use strict";
-    init_constructors2();
-    init_constructor_parameter_settlement();
-    init_members();
-    init_neo_script_derived_bodies();
-    init_value_comparison();
-  }
-});
-
 // src/project-source/root-source.ts
 function emitProjectRootSourceV4(records2, manifest, materializedConstructors, localValues, options = {}) {
   const project = [...records2.values()].find(
@@ -127041,7 +127804,8 @@ function computeWorkspaceStatus(workspace, options) {
         diagnostic2.range.start.line + 1,
         diagnostic2.range.start.character + 1,
         diagnostic2.code,
-        diagnostic2.severity
+        diagnostic2.severity,
+        diagnostic2.range
       );
       if (positioned.severity === "error") parseErrors.push(positioned);
       else parseWarnings.push(positioned);
@@ -127548,10 +128312,28 @@ function computeWorkspaceStatus(workspace, options) {
     ],
     staticMemberValueIds
   );
-  const dialogueRecords = lowerDialogueProjectSourcesV4(
-    prospectiveState,
-    projectAnalysisV4
-  );
+  const dialogueBodySources = /* @__PURE__ */ new Map();
+  let dialogueRecords;
+  try {
+    dialogueRecords = lowerDialogueProjectSourcesV4(
+      prospectiveState,
+      projectAnalysisV4,
+      {
+        authoredValueSeeds,
+        manifest,
+        sourceCapture: {
+          texts: new Map(
+            compilationSources.filter((input) => input.uri.endsWith(".neoflow")).map((input) => [input.uri, new SourceText(input.text)])
+          ),
+          bodies: dialogueBodySources
+        }
+      }
+    );
+  } catch (error) {
+    if (!(error instanceof SchemaSourceError)) throw error;
+    parseErrors.push(error);
+    return refusedStatus(conflictedFiles, parseErrors, parseWarnings);
+  }
   reportPhase("supplemental-dialogue", "Comparing records\u2026");
   records2.push(
     ...staticValues.records,
@@ -128067,6 +128849,7 @@ function computeWorkspaceStatus(workspace, options) {
     );
   return {
     ...projectAnalysisV4 === null ? {} : {
+      dialogueBodySources,
       sourceSnapshot: {
         inputs: compilationSources,
         analysis: projectAnalysisV4
@@ -129127,6 +129910,7 @@ var ANIMATION_DOCUMENT_RECORD_KINDS, ANIMATION_REPLAY_RECORD_KINDS, PROSPECTIVE_
 var init_workspace_status_core = __esm({
   "src/project-source/workspace-status-core.ts"() {
     "use strict";
+    init_source_text();
     init_runtime_diagnostic();
     init_NSGetterRuntimeError();
     init_lower_support();
@@ -131436,7 +132220,15 @@ function buildValueLowerContext(state, manifest, options = {}) {
   let storedValuePlacements;
   const readStoredValuePlacements = () => storedValuePlacements ??= buildStoredValuePlacementIndexV4(stateRecords);
   let rootValueTargets;
+  let referenceTypes;
+  const readReferenceTypes = () => referenceTypes ??= new ReferenceTargetTypes(
+    state,
+    void 0,
+    registry.pendingValues.values(),
+    manifest
+  );
   return {
+    referenceTypes: readReferenceTypes,
     listenerBindings: registry.listenerBindings,
     misplacedLocalListeners: registry.misplacedLocalListeners,
     localValues: registry.localValues ??= new LocalValueBindingsV4(
@@ -132105,6 +132897,21 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
         continue;
       }
       if (!defaultRequiresOwnedRows(context, member, expression, binding)) {
+        if (member.kind === "lookup" || member.kind === "dialogueLookup") {
+          const entries = expression.kind === "litList" ? expression.elements : [expression];
+          for (const entry of entries) {
+            const target = referenceTargetSpelling(context, entry);
+            if (target?.spelling !== "id" && target?.spelling !== "symbol")
+              continue;
+            context.referenceObligations.push({
+              kind: "reference",
+              site: referenceSite(binding, entry),
+              memberId,
+              ownerValueId: null,
+              target
+            });
+          }
+        }
         continue;
       }
       const rootValueId = pendingValueId(binding, `${label}.default`);
@@ -135969,6 +136776,12 @@ function validateReferenceContract(context, member, target, ownerValueId) {
         `Lookup member ${member.name} target ${target.id} is ${classDisplayName2(context, actualClassId)}, but the member declares ${classDisplayName2(context, declaredClassId)} \u2014 ${narrowedFrom} and this member narrows it. Point it at a ${classDisplayName2(context, declaredClassId)} row.`
       );
     }
+    if (target.genericTypeName)
+      context.referenceTypes().assertAssignable(
+        target.id,
+        target.genericTypeName,
+        `Reference<${target.genericTypeName}>`
+      );
     if (target.genericTypeName && expectedTypeName && !referenceTypeNameAssignable(
       context,
       target.genericTypeName,
@@ -138919,6 +139732,7 @@ var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, M
 var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
+    init_reference_target_types();
     init_listener_template_graph();
     init_listener_template_type();
     init_project_root_members();
@@ -140949,6 +141763,75 @@ var init_project_file_source_preservation = __esm({
   }
 });
 
+// src/project-source/dialogue-source-diagnostic.ts
+function locateDialogueSourceError(error, sources2, texts, assigned) {
+  if (!(error instanceof SourceBodyCompileError) || !sources2) return error;
+  let bodyId = error.bodyId;
+  for (const [pending, final] of assigned)
+    if (final === bodyId) {
+      bodyId = pending;
+      break;
+    }
+  const body = sources2.get(bodyId);
+  if (!body) return error;
+  const { location: location3 } = body;
+  const text = texts.get(location3.uri);
+  let range2 = location3.range;
+  let line = range2.start.line + 1;
+  let column = range2.start.character + 1;
+  if (text !== void 0) {
+    const source = new SourceText(text);
+    const start = source.offsetAt(range2.start);
+    const authored = lex(
+      text.slice(start, source.offsetAt(range2.end))
+    ).tokens.filter(
+      (token) => token.kind !== "comment" && token.kind !== "eof"
+    );
+    if (authored[0]?.text === "{" && authored.at(-1)?.text === "}") {
+      range2 = {
+        start: source.positionAt(start + authored[0].end),
+        end: source.positionAt(start + authored.at(-1).start)
+      };
+    }
+    const map = createNeoScriptSourceMap(
+      error.code,
+      source,
+      range2,
+      {
+        name: body.name,
+        uri: location3.uri,
+        coordinateSpace: "file"
+      },
+      body.thisAlias
+    );
+    const position = map && sourcePositionMapper(map)({
+      line: error.compileError.line,
+      column: error.compileError.column
+    });
+    if (position) ({ line, column } = position);
+  }
+  const message = error.compileError.message.replace(/^\d+:\d+: /u, "");
+  return new SchemaSourceError(
+    `${body.name}: ${message}`,
+    location3.uri,
+    line,
+    column,
+    "neoflow-compile",
+    "error",
+    range2
+  );
+}
+var init_dialogue_source_diagnostic = __esm({
+  "src/project-source/dialogue-source-diagnostic.ts"() {
+    "use strict";
+    init_lexer();
+    init_source_text();
+    init_compiler();
+    init_general_function_call_ir_source_recompile();
+    init_source_diagnostics();
+  }
+});
+
 // ../packages/neoscript-language/src/local-scope-index.ts
 var LocalScopeIndex;
 var init_local_scope_index = __esm({
@@ -146232,6 +147115,7 @@ function projectSemanticTokens(document, analysis) {
   const index = buildProjectSymbolIndex(analysis.symbols);
   const tokens = projectTokens(document);
   const bodyContexts = projectBodies(analysis, document.uri);
+  const source = analysis.documents.get(document.uri);
   const result = tokens.flatMap((token, tokenIndex) => {
     if (token.kind === "eof" || token.kind === "error") return [];
     if (rangeItemAt(bodyContexts, token.range.start)) {
@@ -146242,6 +147126,14 @@ function projectSemanticTokens(document, analysis) {
     let type;
     if (declaration) {
       type = projectSemanticTokenType(declaration);
+    } else if (NEOFLOW_GRAPH_TYPES.has(token.text) && (source && sourceTypeAt(source, token.range.start) || tokens[tokenIndex + 1] && symbolsDeclaredAt(
+      index,
+      document.uri,
+      tokens[tokenIndex + 1].range
+    ).some(
+      (symbol) => symbol.kind === "graphChild" && symbol.detail === token.text
+    ))) {
+      type = "type";
     } else if (resolved) {
       type = projectSemanticTokenType(resolved);
     } else if (token.kind === "keyword") type = "keyword";
@@ -146326,6 +147218,7 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
       (symbol) => symbol.kind === "class" || symbol.kind === "interface" || symbol.kind === "enum" || symbol.kind === "genericParameter"
     );
     if (types.length === 1) return { token, symbol: types[0] };
+    if (typePosition) return null;
   }
   const scoped = candidates.filter(
     (symbol) => symbol.scopeRange && symbol.location.uri === document.uri && rangeContains(symbol.scopeRange, token.range.start)
@@ -147155,6 +148048,7 @@ var init_project_source_language_features = __esm({
     init_analyzer();
     init_lexer();
     init_language_spec();
+    init_neoflow_graph_parser();
     init_project_source_semantics();
     init_project_source_variants();
     init_project_source_lifecycle_editor();
@@ -169073,6 +169967,15 @@ function candidateTimestamp(purpose) {
   return purpose === "export" /* Export */ ? 1 : Date.now();
 }
 function locateStoredClosureCaptureError(error, status, assigned) {
+  const located = locateDialogueSourceError(
+    error,
+    status.dialogueBodySources,
+    new Map(
+      status.sourceSnapshot?.inputs.map((input) => [input.uri, input.text])
+    ),
+    assigned
+  );
+  if (located !== error) return located;
   if (!(error instanceof StoredClosureCaptureError)) return error;
   let valueId = error.valueId;
   for (const [pendingId2, assignedId] of assigned) {
@@ -171058,6 +171961,7 @@ var compileNSVoidBody2, compileNSFunction2, compileNSGetter2, compileNSSetter2,
 var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
+    init_dialogue_source_diagnostic();
     init_lower_constructors();
     init_neoscript_source_catalog();
     init_src2();
@@ -184929,7 +185833,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.71.1");
+    console.log("0.71.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {