@neocompose/cli 0.84.1 → 0.84.3

package/dist/neo-runtime.mjs

@@ -17587,7 +17587,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.84.1",
+      cliVersion: "0.84.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -21418,7 +21418,8 @@ var init_executable_parser = __esm({
         }
         if (isIdentifier(t) && t.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD) {
           this.next();
-          const className = isIdentifier(this.peek()) ? this.next().text : null;
+          const classToken = isIdentifier(this.peek()) ? this.next() : null;
+          const className = classToken?.text ?? null;
           const typeArguments = [];
           if (this.eat("operator", "<")) {
             if (className === null) {
@@ -21452,6 +21453,7 @@ var init_executable_parser = __esm({
           return {
             kind: "new",
             className,
+            ...classToken ? { classNamePos: at(classToken) } : {},
             ...typeArguments.length > 0 ? { typeArguments } : {},
             args,
             ...hasArgumentList ? { hasArgumentList: true } : {},
@@ -26054,13 +26056,29 @@ function memberSavedForStorage(ctx, memberId, contextSaved, declarationClassId)
     if (isWritableConstraint(classStorage)) return true;
     if (classStorage === 1 /* Immutable */) return false;
   }
-  const effective = ctx.storageResolver.effectiveStorages(memberId);
+  let effective = ctx.storageResolver.effectiveStorages(memberId);
+  const visited = /* @__PURE__ */ new Set([memberId]);
+  let currentId = memberId;
+  let baseId = member?.extendsMemberId;
+  while (effective.size === 0 && baseId !== void 0 && !visited.has(baseId)) {
+    if (!isResolvedAbstract(ctx, currentId) && !isResolvedAbstract(ctx, baseId))
+      break;
+    visited.add(baseId);
+    effective = ctx.storageResolver.effectiveStorages(baseId);
+    currentId = baseId;
+    baseId = ctx.exportData.members[baseId]?.extendsMemberId;
+  }
   const hasWritable = effective.has(2 /* Save */) || effective.has(3 /* Session */);
   const hasStatic = effective.has(1 /* Immutable */);
   if (hasWritable && !hasStatic) return true;
   if (hasStatic && !hasWritable) return false;
   return contextSaved;
 }
+function isResolvedAbstract(ctx, memberId) {
+  return isAbstractMember(
+    resolveMemberById(ctx, memberId, `members.${memberId}`)
+  );
+}
 function classAllowedStorage(ctx, classId) {
   return ctx.storageResolver.allowedStorage(classId);
 }
@@ -26950,7 +26968,7 @@ function typeInfoConstructedSuffix(ctx, typeInfo, saved, genericEnv, genericBind
     const argType = csharpTypeInfoValueType(
       ctx,
       argInfo,
-      saved,
+      true,
       genericEnv,
       genericBindingSaved
     );
@@ -31635,6 +31653,22 @@ function neoScriptMemberLookupType(type) {
   }
   return nullable2 && current.nullable !== true ? { ...current, nullable: true } : current;
 }
+function neoScriptMemberReceiverType(type, memberName, project) {
+  const primary = neoScriptMemberLookupType(type);
+  if (primary.kind !== "named" || primary.narrowedInterfaces === void 0)
+    return primary;
+  const declaration = project.typeById.get(primary.typeId);
+  if (declaration?.kind === "class" && (memberName === NEOSCRIPT_CLASS_ID_MEMBER || memberName === "Clone"))
+    return primary;
+  if (declaration?.members.some((member) => member.name === memberName))
+    return primary;
+  for (const bound of Object.values(primary.narrowedInterfaces)) {
+    if (project.typeById.get(bound.typeId)?.members.some((member) => member.name === memberName)) {
+      return { ...bound, nullable: primary.nullable === true };
+    }
+  }
+  return primary;
+}
 function isNeoScriptHandleReferenceTarget(target, isValueType) {
   switch (target.kind) {
     case "list":
@@ -31952,6 +31986,20 @@ function isNeoScriptTypeAssignable(source, target, project) {
   if (isUnknownType(source) || isUnknownType(target)) return false;
   if (isNullType(source)) return isNullableType2(target);
   if (isNullableType2(source) && !isNullableType2(target)) return false;
+  if (target.kind === "named" && target.narrowedInterfaces !== void 0) {
+    for (const bound of Object.values(target.narrowedInterfaces)) {
+      if (!isNeoScriptTypeAssignable(source, bound, project)) return false;
+    }
+  }
+  if (source.kind === "named" && source.narrowedInterfaces !== void 0) {
+    const direct = target.kind === "named" ? source.narrowedInterfaces[target.typeId] : void 0;
+    if (direct !== void 0 && isNeoScriptTypeAssignable(direct, target, project))
+      return true;
+    for (const bound of Object.values(source.narrowedInterfaces)) {
+      if (bound !== direct && isNeoScriptTypeAssignable(bound, target, project))
+        return true;
+    }
+  }
   if (source.kind === "primitive" && target.kind === "primitive") {
     if (source.name === target.name) return true;
     return source.name === "int" && (target.name === "float" || target.name === "decimal");
@@ -32036,9 +32084,40 @@ function isNeoScriptTypeAssignable(source, target, project) {
   }
   return false;
 }
+function withoutNeoScriptInterfaceProofs(type) {
+  if (type.kind !== "named" || type.narrowedInterfaces === void 0)
+    return type;
+  const { narrowedInterfaces: _proofs, ...declared } = type;
+  return declared;
+}
 function commonNeoScriptAssignableType(left, right, project) {
   if (isNeoScriptTypeAssignable(left, right, project)) return right;
   if (isNeoScriptTypeAssignable(right, left, project)) return left;
+  if (left.kind === "named" && right.kind === "named" && (left.narrowedInterfaces !== void 0 || right.narrowedInterfaces !== void 0)) {
+    const declaredLeft = withoutNeoScriptInterfaceProofs(left);
+    const declaredRight = withoutNeoScriptInterfaceProofs(right);
+    const common = commonNeoScriptAssignableType(
+      declaredLeft,
+      declaredRight,
+      project
+    );
+    if (common?.kind !== "named") return null;
+    const proofs = {};
+    for (const [source, other] of [
+      [left, right],
+      [right, left]
+    ]) {
+      for (const [id2, proof] of Object.entries(
+        source.narrowedInterfaces ?? {}
+      )) {
+        if (proofs[id2] !== void 0) continue;
+        const opposite = other.narrowedInterfaces?.[id2] ?? other;
+        if (isNeoScriptTypeAssignable(opposite, proof, project))
+          proofs[id2] = proof;
+      }
+    }
+    return { ...common, narrowedInterfaces: proofs };
+  }
   return null;
 }
 function isNeoVariantTypeId(typeId, project) {
@@ -34302,17 +34381,22 @@ function mergeFactSets(sets) {
     )
   );
 }
-function mergeNarrowingMaps(maps) {
+function mergeNarrowingMaps(maps, project) {
   const first = maps[0];
   if (!first) return /* @__PURE__ */ new Map();
   const result = /* @__PURE__ */ new Map();
   for (const [path, narrowed] of first) {
-    if (maps.slice(1).every((map) => {
-      const candidate = map.get(path);
-      return candidate?.rootEntry === narrowed.rootEntry && typeRefsEqual(candidate.type, narrowed.type);
-    })) {
-      result.set(path, narrowed);
+    let common = narrowed.type;
+    for (let index = 1; index < maps.length; index++) {
+      const candidate = maps[index].get(path);
+      if (candidate?.rootEntry !== narrowed.rootEntry) {
+        common = null;
+        break;
+      }
+      common = commonNeoScriptAssignableType(common, candidate.type, project);
+      if (common === null) break;
     }
+    if (common !== null) result.set(path, { ...narrowed, type: common });
   }
   return result;
 }
@@ -34341,6 +34425,16 @@ function typeRefsEqual(left, right) {
   if (left.kind === "named" && right.kind === "named") {
     const leftArgs = left.typeArguments ?? [];
     const rightArgs = right.typeArguments ?? [];
+    if (left.narrowedInterfaces !== right.narrowedInterfaces) {
+      const leftBounds = Object.entries(left.narrowedInterfaces ?? {});
+      const rightBounds = right.narrowedInterfaces ?? {};
+      if (leftBounds.length !== Object.keys(rightBounds).length) return false;
+      for (const [id2, leftBound] of leftBounds) {
+        const rightBound = rightBounds[id2];
+        if (rightBound === void 0 || !typeRefsEqual(leftBound, rightBound))
+          return false;
+      }
+    }
     return left.typeId === right.typeId && leftArgs.length === rightArgs.length && leftArgs.every((item, index) => {
       const other = rightArgs[index];
       return other !== void 0 && typeRefsEqual(item, other);
@@ -35320,6 +35414,10 @@ function typesOverlap(left, right, project) {
   if (isUnknown(left) || isUnknown(right)) return true;
   if (isNull(left)) return isNullable(right);
   if (isNull(right)) return isNullable(left);
+  left = neoScriptMemberLookupType(left);
+  right = neoScriptMemberLookupType(right);
+  if (left.kind === "typeParameter" || right.kind === "typeParameter")
+    return true;
   if (isNeoScriptTypeAssignable(left, right, project) || isNeoScriptTypeAssignable(right, left, project))
     return true;
   if (left.kind === "named" && right.kind === "named") {
@@ -36689,7 +36787,7 @@ var init_strict_resolver = __esm({
                 statement.init.pos
               );
             }
-            const localType = declared ?? initial.type;
+            const localType = declared ?? withoutNeoScriptInterfaceProofs(initial.type);
             if (declared) {
               this.requireAssignable(
                 initial.type,
@@ -36704,16 +36802,18 @@ var init_strict_resolver = __esm({
               initial.pointer,
               this.project
             );
-            scope.define(
-              scopeVariable(
-                statement.name,
-                local,
-                localType,
-                "local" /* Local */,
-                localOwnership(initial),
-                this.localWriteTargetRoot(initial, scope)
-              )
+            const entry = scopeVariable(
+              statement.name,
+              local,
+              localType,
+              "local" /* Local */,
+              localOwnership(initial),
+              this.localWriteTargetRoot(initial, scope)
             );
+            scope.define(entry);
+            if (inferred && localType !== initial.type) {
+              scope.narrow(statement.name, entry, initial.type);
+            }
             return { type: "variable" /* Variable */, variable: local };
           }
           case "if": {
@@ -36768,7 +36868,8 @@ var init_strict_resolver = __esm({
             mergeBranchInvalidations(scope, branchExitOwnershipScopes);
             if (branchExitNarrowings.length > 0) {
               for (const [path, narrowed] of mergeNarrowingMaps(
-                branchExitNarrowings
+                branchExitNarrowings,
+                this.project
               )) {
                 const rootEntry = scope.lookup(pathRoot(path));
                 if (rootEntry === narrowed.rootEntry) {
@@ -37694,7 +37795,7 @@ var init_strict_resolver = __esm({
       }
       mergeLoopNarrowings(parent, exitPaths) {
         if (exitPaths.length === 0) return;
-        const merged = mergeNarrowingMaps(exitPaths);
+        const merged = mergeNarrowingMaps(exitPaths, this.project);
         for (const [path, narrowed] of parent.effectiveNarrowedPaths()) {
           const common = merged.get(path);
           if (parent.containsEntry(narrowed.rootEntry) && (common?.rootEntry !== narrowed.rootEntry || !typeRefsEqual(common.type, narrowed.type))) {
@@ -39447,8 +39548,13 @@ var init_strict_resolver = __esm({
               expression.receiver,
               scope
             );
-            if (receiverExpression.type.kind !== "named") return null;
-            owner = this.project.typeById.get(receiverExpression.type.typeId);
+            const memberType2 = neoScriptMemberReceiverType(
+              receiverExpression.type,
+              expression.name,
+              this.project
+            );
+            if (memberType2.kind !== "named") return null;
+            owner = this.project.typeById.get(memberType2.typeId);
             symbol = owner?.members.find(
               (candidate) => candidate.name === expression.name && (candidate.kind === "function" || candidate.kind === "method")
             );
@@ -39459,7 +39565,10 @@ var init_strict_resolver = __esm({
                 expression.pos
               );
             }
-            receiver = { kind: "instance", expression: receiverExpression };
+            receiver = {
+              kind: "instance",
+              expression: { ...receiverExpression, type: memberType2 }
+            };
           }
         } else {
           return null;
@@ -39536,9 +39645,13 @@ var init_strict_resolver = __esm({
             if (symbol === void 0 || symbol.static !== true) return null;
           } else {
             const receiver2 = this.resolveExpression(expression.receiver, scope);
-            if (receiver2.type.kind !== "named") return null;
-            receiverType = receiver2.type;
-            owner = this.project.typeById.get(receiver2.type.typeId);
+            receiverType = neoScriptMemberReceiverType(
+              receiver2.type,
+              expression.name,
+              this.project
+            );
+            if (receiverType.kind !== "named") return null;
+            owner = this.project.typeById.get(receiverType.typeId);
             symbol = owner?.members.find(
               (candidate) => candidate.name === expression.name && (candidate.kind === "function" || candidate.kind === "method")
             );
@@ -39616,6 +39729,7 @@ var init_strict_resolver = __esm({
             pos
           );
         }
+        entryType = withoutNeoScriptInterfaceProofs(entryType);
         for (const item of resolved) {
           const common = commonNeoScriptAssignableType(
             entryType,
@@ -39640,7 +39754,7 @@ var init_strict_resolver = __esm({
         }
         const type = {
           kind: "list",
-          elementType: entryType
+          elementType: withoutNeoScriptInterfaceProofs(entryType)
         };
         const wire = toWireType(type, this.project);
         if (wire.type !== 6 /* List */) {
@@ -39706,6 +39820,7 @@ var init_strict_resolver = __esm({
         if (!keyType || !valueType) {
           throw new CompileError("Dictionary literal type inference failed.", pos);
         }
+        valueType = withoutNeoScriptInterfaceProofs(valueType);
         for (const entry of resolved) {
           if (expectedDictionary) {
             this.requireAssignable(
@@ -39732,7 +39847,7 @@ var init_strict_resolver = __esm({
         const type = {
           kind: "dictionary",
           keyType,
-          valueType
+          valueType: withoutNeoScriptInterfaceProofs(valueType)
         };
         const wire = toWireType(type, this.project);
         if (wire.type !== 5 /* Dictionary */) {
@@ -39988,8 +40103,19 @@ var init_strict_resolver = __esm({
             const target = this.resolveType(fact.targetType);
             const targetDefinition = target.kind === "named" ? this.project.typeById.get(target.typeId) : void 0;
             const naturalDefinition = natural.type.kind === "named" ? this.project.typeById.get(natural.type.typeId) : void 0;
-            const retainConcreteClass = !fact.bindingName && naturalDefinition?.kind === "class" && targetDefinition?.kind === "interface";
-            const narrowed = retainConcreteClass ? { ...natural.type, nullable: false } : { ...target, nullable: false };
+            let narrowed = { ...target, nullable: false };
+            if (!fact.bindingName && natural.type.kind === "named" && (naturalDefinition?.kind === "class" || naturalDefinition?.kind === "interface") && target.kind === "named" && targetDefinition?.kind === "interface") {
+              narrowed = { ...natural.type, nullable: false };
+              if (!isNeoScriptTypeAssignable(narrowed, target, this.project)) {
+                narrowed = {
+                  ...narrowed,
+                  narrowedInterfaces: {
+                    ...natural.type.narrowedInterfaces,
+                    [target.typeId]: target
+                  }
+                };
+              }
+            }
             if (mode === "all" && fact.path !== null && rootEntry !== null && place.type.kind !== "reference") {
               targetScope.narrow(fact.path, rootEntry, narrowed);
             }
@@ -40582,7 +40708,11 @@ var init_strict_resolver = __esm({
         if (receiver.dialogues !== void 0) {
           return this.resolveDialogueGroupRead(receiver, name, pos);
         }
-        const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        const memberReceiverType = neoScriptMemberReceiverType(
+          receiver.type,
+          name,
+          this.project
+        );
         if (memberReceiverType.kind === "named") {
           const type = this.project.typeById.get(memberReceiverType.typeId);
           if (!type) {
@@ -41394,7 +41524,7 @@ var init_strict_resolver = __esm({
         }
         const type = {
           kind: "list",
-          elementType: entryType
+          elementType: withoutNeoScriptInterfaceProofs(entryType)
         };
         const wire = toWireType(type, this.project);
         if (wire.type !== 6 /* List */) {
@@ -41635,7 +41765,11 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        const memberReceiverType = neoScriptMemberReceiverType(
+          receiver.type,
+          callee.name,
+          this.project
+        );
         const namedType2 = memberReceiverType.kind === "named" ? this.project.typeById.get(memberReceiverType.typeId) : void 0;
         const member = namedType2?.members.find(
           (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
@@ -44060,7 +44194,11 @@ var init_strict_resolver = __esm({
         }
         const receiver = receiverValue();
         if (receiver.dialogues !== void 0) return null;
-        const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        const memberReceiverType = neoScriptMemberReceiverType(
+          receiver.type,
+          memberName,
+          this.project
+        );
         if (memberReceiverType.kind !== "named") return null;
         const type = this.project.typeById.get(memberReceiverType.typeId);
         const symbol = type?.members.find(
@@ -50978,7 +51116,29 @@ function validateExpression(expression, expected, scope, environment, uri, range
       );
       return;
     }
-    if (!declaration) return;
+    if (!declaration) {
+      if (expression.className !== null && !environment.projectIndex.typeByName.has(expression.className) && semanticTypeRef(
+        {
+          name: expression.className,
+          ...expression.typeArguments ? { arguments: expression.typeArguments.map(semanticAstType) } : {}
+        },
+        scope,
+        environment
+      ) === void 0) {
+        pushDiagnostic(
+          diagnostics,
+          uri,
+          anchor ? anchorSpan(
+            anchor,
+            expression.classNamePos ?? expression.pos,
+            expression.className.length
+          ) : range2,
+          "unknown-construction-type",
+          `Unknown class '${expression.className}'.`
+        );
+      }
+      return;
+    }
     if (declaration.modifiers.includes("abstract")) {
       pushDiagnostic(
         diagnostics,
@@ -55341,7 +55501,7 @@ function sourceParameter(parameter4, owner, typeIds, id2, functionTypeParameters
   };
 }
 function substituteInheritedSourceMember(member, baseInfo, resolvedBaseType) {
-  if (baseInfo.declaration.kind !== "class" || resolvedBaseType.kind !== "named") {
+  if (baseInfo.declaration.kind !== "class" && baseInfo.declaration.kind !== "interface" || resolvedBaseType.kind !== "named") {
     return {
       ...member,
       inheritedFrom: member.inheritedFrom ?? {
@@ -82579,6 +82739,7 @@ function createdSessionValuesSince(ctx, checkpoint) {
   return created;
 }
 function exportInitializerCollections(created, writes, ctx) {
+  const inPlace = (value) => value instanceof RuntimeSet ? exportRuntimeSetValue(value, ctx) : value;
   const assignedValues = /* @__PURE__ */ new Set();
   const mutatedIds = /* @__PURE__ */ new Set();
   for (const write of writes) {
@@ -82586,83 +82747,134 @@ function exportInitializerCollections(created, writes, ctx) {
     if (destination !== void 0 && "containerValueId" in destination)
       mutatedIds.add(destination.containerValueId);
     if (write.kind === "assign" && write.valueId === void 0 && typeof write.value === "object" && write.value !== null) {
-      assignedValues.add(write.value);
+      assignedValues.add(inPlace(write.value));
     }
   }
   const candidates = /* @__PURE__ */ new Set();
+  const inlineFieldsByRowId = /* @__PURE__ */ new Map();
   for (const row of created) {
-    if (assignedValues.has(row.value) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
+    const inlineFields = inlineCollectionFields(row, ctx);
+    if (inlineFields !== null) inlineFieldsByRowId.set(row.id, inlineFields);
+    if (inlineFields !== null || assignedValues.has(inPlace(row.value)) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
       candidates.add(row.id);
     }
   }
   if (candidates.size === 0) return created;
   invalidateEvaluatorIndexes(ctx, null);
   const extra = [];
-  const exported = created.map((row) => {
-    if (!candidates.has(row.id)) return row;
-    const member = memberForValueRow(row, ctx);
-    if (member === null) return row;
-    if (!isMemberWithEntries(member)) return row;
-    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
-      return { ...row, value: [] };
-    }
-    if (!assignedValues.has(row.value) && !mutatedIds.has(row.id)) return row;
-    const values = [];
+  const encode = (member, value, genericEnv, collectionOwnerId) => {
+    const rows = [];
     const declarations = /* @__PURE__ */ new Map();
-    const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
-    overlayConcreteGenericEntries(
-      genericEnv,
-      envFromStamp(row.genericBindings)
-    );
-    const materialized = materializeConstructorArgumentValue({
+    const root = materializeConstructorArgumentValue({
       member,
-      value: row.value,
+      value,
       genericEnv,
       ctx,
-      createdValues: values,
+      createdValues: rows,
       createdById: /* @__PURE__ */ new Map(),
       storageKeyDeclarations: declarations,
-      collectionEntriesAreReferences: assignedValues.has(row.value) ? false : void 0,
-      collectionOwnerId: row.id
-    });
-    const encoded = { ...row, value: materialized.value };
-    const children = values.filter((value) => value !== materialized);
-    declarations.delete(materialized.id);
-    const groupId = constructorGroupForRow(row.id, ctx);
-    retargetConstructorGroupDependencies(
-      materialized.id,
-      groupId ?? row.id,
-      ctx
-    );
+      collectionEntriesAreReferences: assignedValues.has(value) ? false : void 0,
+      collectionOwnerId
+    });
+    const children = rows.filter((row) => row !== root);
+    return { root, children, declarations };
+  };
+  const adopt = (owner, rootId, rows, declarations) => {
+    const groupId = constructorGroupForRow(owner.id, ctx);
+    retargetConstructorGroupDependencies(rootId, groupId ?? owner.id, ctx);
     if (groupId !== null) {
       const state = ctx.__executionState;
       const group = state?.constructorGroups.get(groupId);
-      for (const child2 of children) {
-        retargetConstructorGroupDependencies(child2.id, groupId, ctx);
-        group?.add(child2.id);
-        state?.constructorGroupByRowId.set(child2.id, groupId);
+      for (const row of rows) {
+        retargetConstructorGroupDependencies(row.id, groupId, ctx);
+        group?.add(row.id);
+        state?.constructorGroupByRowId.set(row.id, groupId);
       }
     }
-    stampCreatedValuesMapKey(children, row.mapKey);
+    stampCreatedValuesMapKey(rows, owner.mapKey);
     applyDeclaredStorageKeyOverrides({
-      createdValues: [encoded, ...children],
+      createdValues: [owner, ...rows],
       declarationByValueId: declarations
     });
-    for (const child2 of children) {
-      if (!isLiteralValueContent(child2)) {
+    for (const row of rows) {
+      if (!isLiteralValueContent(row)) {
         throw new NSGetterRuntimeError(
           "Initializer collection produced an unevaluated row."
         );
       }
-      extra.push(child2);
+      extra.push(row);
     }
     for (const [id2, declaration] of declarations) {
       ctx.__createdStorageKeyDeclarations?.set(id2, declaration);
     }
+  };
+  const exported = created.map((row) => {
+    if (!candidates.has(row.id)) return row;
+    const inlineFields = inlineFieldsByRowId.get(row.id);
+    if (inlineFields !== void 0) {
+      const record7 = { ...inlineFields.record };
+      const encoded2 = { ...row, value: record7 };
+      for (const [key, member2] of inlineFields.members) {
+        const { root: root2, children: children2, declarations: declarations2 } = encode(
+          member2,
+          inPlace(record7[key]),
+          inlineFields.genericEnv
+        );
+        record7[key] = root2.id;
+        adopt(encoded2, root2.id, [root2, ...children2], declarations2);
+      }
+      return encoded2;
+    }
+    const member = memberForValueRow(row, ctx);
+    if (member === null) return row;
+    if (!isMemberWithEntries(member)) return row;
+    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
+      return { ...row, value: [] };
+    }
+    const value = inPlace(row.value);
+    if (!assignedValues.has(value) && !mutatedIds.has(row.id)) return row;
+    const { root, children, declarations } = encode(
+      member,
+      value,
+      rowGenericEnv(row, ctx),
+      row.id
+    );
+    const encoded = { ...row, value: root.value };
+    declarations.delete(root.id);
+    adopt(encoded, root.id, children, declarations);
     return encoded;
   });
   return [...exported, ...extra];
 }
+function inlineCollectionFields(row, ctx) {
+  if (typeof row.classId !== "string") return null;
+  if (!isPlainRecord2(row.value)) return null;
+  let fields = null;
+  for (const key in row.value) {
+    const value = row.value[key];
+    if (typeof value !== "object" || value === null) continue;
+    const rawMember = memberForCustomSchemaValue(row.classId, key, ctx);
+    if (rawMember === null) continue;
+    fields ??= {
+      record: row.value,
+      members: /* @__PURE__ */ new Map(),
+      genericEnv: rowGenericEnv(row, ctx)
+    };
+    const member = substituteMember(
+      rawMember,
+      fields.genericEnv,
+      ctx.vm.members,
+      cachedResolvedMember(rawMember, ctx)
+    );
+    if (isMemberWithEntries(member)) fields.members.set(key, member);
+  }
+  return fields === null || fields.members.size === 0 ? null : fields;
+}
+function rowGenericEnv(row, ctx) {
+  const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
+  overlayConcreteGenericEntries(genericEnv, envFromStamp(row.genericBindings));
+  return genericEnv;
+}
 function prepareSessionValueExport(ctx, checkpoint, writes) {
   const created = createdSessionValuesSince(ctx, checkpoint);
   if (created.length === 0) return;
@@ -94015,6 +94227,7 @@ function clonedConstructorProvenance(source) {
 }
 function cloneConstructorLiteralValue(value) {
   if (typeof value !== "object" || value === null) return value;
+  if (value instanceof NSSlotReference) return value.targetId;
   if (Array.isArray(value)) {
     return value.map((entry) => cloneConstructorLiteralValue(entry));
   }
@@ -96060,7 +96273,7 @@ var init_constructor_argument_ownership = __esm({
               const typeInfo = parameterTypes.get(parameterId);
               return [
                 parameterId,
-                typeInfo !== void 0 && isAggregateTypeInfo(typeInfo) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
+                typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
               ];
             }
           )
@@ -96096,6 +96309,41 @@ var init_constructor_argument_ownership = __esm({
           ids.push(edge.targetValueId);
         return ids;
       }
+      /** The targets a row's Reference creation data names (P112 §1.1). */
+      referenceArgumentIds(row) {
+        if (!isLiteralValueContent(row)) return [];
+        const args = row.constructorArgs;
+        if (args === void 0 || args === null) return [];
+        const ids = [];
+        for (const parameterId of this.referenceParameterIds(row)) {
+          const argument2 = args[parameterId];
+          if (typeof argument2 === "string") ids.push(argument2);
+        }
+        return ids;
+      }
+      /** Creation data with each Reference argument's target remapped (P112 §1.1). */
+      remapReferenceArguments(row, remap, contextualMember) {
+        const args = row.constructorArgs;
+        if (args === void 0 || args === null) return args;
+        let remapped;
+        for (const parameterId of this.referenceParameterIds(
+          row,
+          contextualMember
+        )) {
+          const argument2 = args[parameterId];
+          if (typeof argument2 !== "string") continue;
+          const target = remap(argument2);
+          if (target !== argument2) (remapped ??= { ...args })[parameterId] = target;
+        }
+        return remapped ?? args;
+      }
+      *referenceParameterIds(row, contextualMember) {
+        for (const [parameterId, typeInfo] of this.constructorParameterTypes(
+          row,
+          contextualMember
+        ))
+          if (typeInfo.type === 29 /* Reference */) yield parameterId;
+      }
       slotEntries(row) {
         const value = row.value;
         switch (this.referenceSlots(row.id, void 0, value)) {
@@ -98003,7 +98251,11 @@ function resolveVirtualInstanceGraph(args) {
         }
       }
     }
-    const virtualRow = rewriteExpandedRow(indexed, expansion);
+    const virtualRow = rewriteExpandedRow(
+      indexed,
+      expansion,
+      materializedGraph
+    );
     const location3 = {
       id: effectiveId2,
       instanceRootId: args.instanceRoot.id,
@@ -99457,6 +99709,16 @@ function sparsifyConstructedInstance(args) {
       protectedValueIds.add(location3.materializedRow.id);
     }
   }
+  const rootId = args.constructed.root.id;
+  const locationValueId = (location3) => args.virtualValueIdForSource?.(rootId, location3.sourceIdentity) ?? location3.virtualRow.id;
+  if (args.bindingTargets !== void 0)
+    pinReferencedSlots(
+      graph,
+      rootId,
+      args.bindingTargets,
+      locationValueId,
+      protectedValueIds
+    );
   let plan;
   try {
     plan = planCollapseVirtualInstance({
@@ -99488,10 +99750,7 @@ function sparsifyConstructedInstance(args) {
     if (real === null || deletedIds.has(real.id)) continue;
     nextIdById.set(
       real.id,
-      location3.parentSegment === null ? args.constructed.root.id : args.virtualValueIdForSource?.(
-        args.constructed.root.id,
-        location3.sourceIdentity
-      ) ?? location3.virtualRow.id
+      location3.parentSegment === null ? rootId : locationValueId(location3)
     );
   }
   nextIdById.set(args.constructed.root.id, args.constructed.root.id);
@@ -99590,6 +99849,8 @@ function restoreRowsRetainedRowsName(materializedGraph, rows, updatedValueById,
       updated === void 0 ? row : { ...row, value: updated }
     ))
       restore(valueId);
+    for (const valueId of materializedGraph.referenceArgumentIds(row))
+      restore(valueId);
     entriesByContainerId ??= buildUnorderedListMembershipIndex(rows);
     for (const valueId of entriesByContainerId.get(row.id) ?? [])
       restore(valueId);
@@ -99712,6 +99973,24 @@ function childEnvForRow(member, row, genericEnv, document) {
   }
   return instanceEnv;
 }
+function pinReferencedSlots(graph, rootId, targets, locationValueId, pinned) {
+  if (targets.ids.size === 0) return;
+  const matched = /* @__PURE__ */ new Set();
+  for (const location3 of graph.locationsByPath.values()) {
+    if (location3.parentSegment === null) continue;
+    const valueId = locationValueId(location3);
+    if (!targets.ids.has(valueId)) continue;
+    matched.add(valueId);
+    if (location3.materializedRow !== null)
+      pinned.add(location3.materializedRow.id);
+  }
+  for (const valueId of targets.pendingIdsByRootId.get(rootId) ?? []) {
+    if (matched.has(valueId)) continue;
+    throw new Error(
+      `A binding names ${valueId}, which construction ${rootId} does not build.`
+    );
+  }
+}
 function indexExpansion(args) {
   const rowsByExpandedId = args.indexedRows?.rowsById ?? new Map([
     ...args.expandedRows.map((row) => [row.id, row]),
@@ -99978,7 +100257,7 @@ function planAtomicCollectionOverrideWrite(args) {
     childId = parent.id;
   }
 }
-function rewriteExpandedRow(node, expansion) {
+function rewriteExpandedRow(node, expansion, graph) {
   const rewrite = (id2) => expansion.nodesByExpandedId.get(id2)?.virtualId ?? id2;
   const row = cloneRow(node.expandedRow);
   row.id = node.virtualId;
@@ -100000,6 +100279,12 @@ function rewriteExpandedRow(node, expansion) {
   if (node.member.kind === 9 /* Lookup */) {
     row.value = remapLookupSelection(row.value, rewrite);
   }
+  if (isLiteralValueContent(row) && row.constructorArgs !== void 0)
+    row.constructorArgs = graph.remapReferenceArguments(
+      row,
+      rewrite,
+      node.member
+    );
   if (typeof row.containerId === "string") {
     row.containerId = rewrite(row.containerId);
   }
@@ -100216,6 +100501,18 @@ function memberIdOf(member) {
 function appendVirtualValuePath(parent, segment) {
   return `${parent}/${JSON.stringify(segment)}`;
 }
+function constructedSlotValueId(rootId, steps) {
+  let pathKey = ROOT_PATH;
+  for (const step of steps)
+    pathKey = appendVirtualValuePath(pathKey, {
+      kind: "class",
+      schemaKey: step.schemaKey
+    });
+  const memberId = steps.at(-1)?.memberId;
+  if (memberId === void 0)
+    throw new Error(`Construction ${rootId} names no slot.`);
+  return derivedVirtualValueId(rootId, `path:${memberId}:${pathKey}`);
+}
 function parentPathKey(pathKey) {
   if (pathKey === ROOT_PATH) return null;
   const separator = lastPathSeparator(pathKey);
@@ -123765,6 +124062,7 @@ var init_collection_binding_materialization = __esm({
   "../src/database/collection-binding-materialization.ts"() {
     "use strict";
     init_members();
+    init_constructor_argument_ownership();
     init_virtual_instance_values();
     init_headless_virtual_instance_lookups();
     init_document_initializer_compiler();
@@ -123781,6 +124079,7 @@ var init_collection_binding_materialization = __esm({
       pathRowsByRootId = /* @__PURE__ */ new Map();
       stored;
       lookups;
+      schema;
       resolvePath(rootId, segments) {
         let id2 = rootId;
         const pathRows = this.pathRowsByRootId.get(rootId) ?? /* @__PURE__ */ new Set();
@@ -123838,17 +124137,20 @@ var init_collection_binding_materialization = __esm({
           valueId: id2,
           value: row.value
         });
+        const created = [];
         for (const create of plan.creates) {
           pathRows?.add(create.id);
           const { valuePlacement: _placement, ...fields } = create;
           const previous = this.rows.get(create.id);
-          this.rows.set(create.id, {
+          const row2 = {
             ...fields,
             value: mergeBodies(fields.value, previous?.value),
             projectId: this.document.project.id,
             createdAt: 0,
             updatedAt: 0
-          });
+          };
+          this.rows.set(create.id, row2);
+          created.push(row2);
         }
         for (const update of plan.updates) {
           pathRows?.add(update.valueId);
@@ -123862,6 +124164,13 @@ var init_collection_binding_materialization = __esm({
             value: mergeBodies(previous.value, update.value)
           });
         }
+        this.schema ??= new MaterializedValueGraphContext({
+          ...this.document,
+          values: []
+        });
+        for (const row2 of created)
+          for (const targetId of this.schema.referenceArgumentIds(row2))
+            if (graph.rowsById.has(targetId)) this.materialize(targetId, pathRows);
         return true;
       }
     };
@@ -124070,6 +124379,42 @@ var init_prepared_collection_bindings = __esm({
   }
 });
 
+// ../src/database/declared-binding-targets.ts
+function declaredBindingTargetIds(document) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const member of document.members) {
+    if (member.kind !== 9 /* Lookup */) continue;
+    if (isMemberCollectionLookupBase(member) && typeof member.collectionValueId === "string")
+      ids.add(member.collectionValueId);
+    const selection2 = isLiteralValueContent(member.defaultValue) ? member.defaultValue.value : void 0;
+    if (typeof selection2 === "string") ids.add(selection2);
+    if (Array.isArray(selection2)) {
+      for (const id2 of selection2) if (typeof id2 === "string") ids.add(id2);
+    }
+  }
+  for (const folder of document.variantFolders ?? [])
+    if (folder.binding !== void 0) ids.add(folder.binding.collectionValueId);
+  for (const group of document.dialogueGroups)
+    if (group.type === 1 /* Lookup */ && typeof group.collectionValueId === "string")
+      ids.add(group.collectionValueId);
+  const pendingIdsByRootId = /* @__PURE__ */ new Map();
+  for (const id2 of ids) {
+    const rootId = pendingVirtualValueIdentity(id2)?.instanceRootId;
+    if (rootId === void 0) continue;
+    const pending = pendingIdsByRootId.get(rootId);
+    if (pending === void 0) pendingIdsByRootId.set(rootId, [id2]);
+    else pending.push(id2);
+  }
+  return { ids, pendingIdsByRootId };
+}
+var init_declared_binding_targets = __esm({
+  "../src/database/declared-binding-targets.ts"() {
+    "use strict";
+    init_members();
+    init_member_value_id();
+  }
+});
+
 // ../src/runtime/stored-closure-captures.ts
 function assertStoredClosuresKeepNoCaptures(args) {
   for (const row of args.rows) {
@@ -127817,6 +128162,7 @@ function materializePreparedInstanceInitializers(args) {
   const localizedTextIds = new Set(
     materializationScope.document.localizedTexts.map((text) => text.id)
   );
+  const bindingTargets = declaredBindingTargetIds(compiledDocument);
   const replayOnlyIndexes = [];
   const pendingSites = /* @__PURE__ */ new Map();
   for (const [valueId, site] of sites) {
@@ -127906,7 +128252,8 @@ function materializePreparedInstanceInitializers(args) {
       // the class default, so the evaluated construction's own field list is
       // what pins rows against collapse.
       pinnedRootSchemaKeys: materialized.pinnedRootSchemaKeys,
-      pinnedSchemaKeysByValueId: materialized.pinnedSchemaKeysByValueId
+      pinnedSchemaKeysByValueId: materialized.pinnedSchemaKeysByValueId,
+      bindingTargets
     });
     assertStoredClosuresKeepNoCaptures({
       sourceValueId: valueId,
@@ -131073,6 +131420,7 @@ var init_project_version_schema_commit = __esm({
     init_neoscript_compiler_revision();
     init_neoscript_source_catalog();
     init_prepared_collection_bindings();
+    init_declared_binding_targets();
     init_stored_closure_captures();
     init_document_initializer_compiler();
     init_effective_value_comparison();
@@ -143486,13 +143834,6 @@ function drainValueReferenceObligationsV4(state, manifest, options) {
       ...composeReferenceSitePosition(move.site, options.sourceTextByUri)
     });
   }
-  for (const recorded of options.registry.loweringFailures) {
-    failures.push({
-      message: recorded.message,
-      ...recorded.code === void 0 ? {} : { code: recorded.code },
-      ...composeReferenceSitePosition(recorded.site, options.sourceTextByUri)
-    });
-  }
   for (const obligation of [
     ...collectionValueObligations(manifest),
     ...options.registry.referenceObligations
@@ -143530,7 +143871,17 @@ function drainValueReferenceObligationsV4(state, manifest, options) {
       ...composeReferenceSitePosition(obligation.site, options.sourceTextByUri)
     });
   }
-  return failures;
+  const loweringFailures = options.registry.loweringFailures.map(
+    (recorded) => recorded instanceof SchemaSourceError ? recorded : {
+      message: recorded.message,
+      ...recorded.code === void 0 ? {} : { code: recorded.code },
+      ...composeReferenceSitePosition(
+        recorded.site,
+        options.sourceTextByUri
+      )
+    }
+  );
+  return [...loweringFailures, ...failures];
 }
 function withoutDeletedValues(state, deletedValueIds) {
   if (deletedValueIds.size === 0) return state;
@@ -150554,6 +150905,11 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         false
       );
     case "reference":
+      if (typeof value !== "string") {
+        throw new Error(
+          "Stored Reference constructor argument is not a target id."
+        );
+      }
       return referenceValue(
         context,
         {
@@ -150561,7 +150917,7 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
           name: "argument",
           kind: 9 /* Lookup */
         },
-        value,
+        [value],
         false,
         storedTypeArgumentName(context, type.target, environment)
       );
@@ -152062,6 +152418,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_source_diagnostics();
     init_immutable_json3();
     init_lower_support();
     init_record_fields();
@@ -153391,6 +153748,7 @@ function materializeInitializersLocallyV4(args) {
   const localizedTextIds = new Set(
     authoredDocument.localizedTexts?.map((text) => text.id)
   );
+  const bindingTargets = declaredBindingTargetIds(authoredDocument);
   const pendingRoots = new Set(
     [...sourceRoots].filter((id2) => rootKinds.get(id2) !== "declaration").sort()
   );
@@ -153587,6 +153945,7 @@ function materializeInitializersLocallyV4(args) {
       // pins rows against collapse. Push preparation pins the same set.
       pinnedRootSchemaKeys: pinned.pinnedRootSchemaKeys,
       pinnedSchemaKeysByValueId: pinned.pinnedSchemaKeysByValueId,
+      bindingTargets,
       virtualValueIdForSource: (instanceRootId, sourceIdentity3) => isPendingId(instanceRootId) || hasPendingVirtualSourceIdentity(sourceIdentity3) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3)
     });
     const evaluatedRows = [sparse2.root, ...sparse2.createdChildren];
@@ -153783,6 +154142,7 @@ var init_local_initializer_materialization = __esm({
     init_inheritance();
     init_effective_value_reader();
     init_virtual_instance_values();
+    init_declared_binding_targets();
     init_value_graph();
     init_pending_id();
     init_value_comparison();
@@ -156832,7 +157192,7 @@ function quote4(value) {
 function resolveRootPathCollectionValuesV4(args) {
   const resolved = /* @__PURE__ */ new Map();
   let rootValues;
-  let placements;
+  let walk;
   for (const member of args.manifest.members) {
     if (member.kind !== "lookup") continue;
     const spelled = member.collectionValueId;
@@ -156854,16 +157214,9 @@ function resolveRootPathCollectionValuesV4(args) {
     };
     const target = walkRootValuePath(
       path,
-      args.state,
-      args.registry,
-      () => placements ??= prospectiveStoredValuePlacements(
-        args.state,
-        args.registry,
-        args.manifest
-      ),
+      walk ??= valuePathWalk(args),
       rootValues,
       fail2,
-      args.resolveVirtualPath,
       args.unavailableSlots
     );
     if (target !== null) resolved.set(member.id, target);
@@ -156873,7 +157226,7 @@ function resolveRootPathCollectionValuesV4(args) {
 function resolveRootPathVariantFolderCollectionValuesV4(args) {
   const resolved = /* @__PURE__ */ new Map();
   let rootValues;
-  let placements;
+  let walk;
   for (const folder of args.manifest.variantFolders) {
     const spelled = folder.binding?.collectionValueId;
     if (typeof spelled !== "string") continue;
@@ -156894,16 +157247,9 @@ function resolveRootPathVariantFolderCollectionValuesV4(args) {
     };
     const target = walkRootValuePath(
       path,
-      args.state,
-      args.registry,
-      () => placements ??= prospectiveStoredValuePlacements(
-        args.state,
-        args.registry,
-        args.manifest
-      ),
+      walk ??= valuePathWalk(args),
       rootValues,
       fail2,
-      args.resolveVirtualPath,
       args.unavailableSlots
     );
     if (target !== null) resolved.set(folder.id, target);
@@ -156911,83 +157257,87 @@ function resolveRootPathVariantFolderCollectionValuesV4(args) {
   return resolved;
 }
 function createRootValuePathResolverV4(args) {
-  let placements;
+  const walk = valuePathWalk(args);
   let rootValues;
-  let computed;
-  const readPlacements = () => placements ??= prospectiveStoredValuePlacements(
-    args.state,
-    args.registry,
-    args.manifest
-  );
-  const settle = (walk2) => {
+  const settle = (resolve7) => {
     const failures = [];
-    const valueId = walk2((failure) => failures.push(failure));
+    const valueId = resolve7((failure) => failures.push(failure));
     if (valueId !== null) {
       const stored = args.state[`value:${valueId}`] !== void 0 || args.registry.pendingValues.has(valueId);
       return {
         kind: "resolved",
         valueId,
-        memberId: readPlacements().placementByChildValueId.get(valueId)?.memberId ?? null,
+        memberId: walk.placements().placementByChildValueId.get(valueId)?.memberId ?? null,
         ...stored ? {} : { virtual: true }
       };
     }
     const message = failures[0];
     return message === void 0 ? { kind: "unavailable" } : { kind: "failed", message };
   };
-  const walk = () => ({
-    state: args.state,
-    registry: args.registry,
-    placements: readPlacements,
-    resolveVirtualPath: args.resolveVirtualPath,
-    isComputed: computed ??= computedMemberTest(args.manifest)
-  });
   return {
     root: (path) => settle((fail2) => {
       if (rootValues === void 0) rootValues = rootSlotValueIds(args.state);
       return walkRootValuePath(
         path,
-        args.state,
-        args.registry,
-        readPlacements,
+        walk,
         rootValues,
         fail2,
-        args.resolveVirtualPath,
         args.unavailableSlots,
-        "Index path",
-        walk().isComputed
+        "Index path"
       );
     }),
     from: (valueId, segments, path) => settle(
-      (fail2) => walkValueSegments(walk(), valueId, segments, path, "Reference", fail2)
+      (fail2) => walkValueSegments(walk, valueId, segments, path, "Reference", fail2)
     )
   };
 }
-function computedMemberTest(manifest) {
+function valuePathWalk(args) {
+  let placements;
+  let schema;
+  return {
+    state: args.state,
+    registry: args.registry,
+    placements: () => placements ??= prospectiveStoredValuePlacements(
+      args.state,
+      args.registry,
+      args.manifest
+    ),
+    schema: () => schema ??= manifestSchemaIndex(args.manifest),
+    resolveVirtualPath: args.resolveVirtualPath,
+    initBuiltSlots: args.initBuiltSlots ?? "derive"
+  };
+}
+function manifestSchemaIndex(manifest) {
   const classes = new Map(
     manifest.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
-  const computed = new Set(
-    manifest.members.flatMap(
-      (member) => member.kind === "computed" ? [member.id] : []
-    )
+  const members = new Map(
+    manifest.members.map((member) => [member.id, member])
   );
-  return (valueId, name, walk) => {
-    const pending = walk.registry.pendingValues.get(valueId);
-    const stored = walk.state[`value:${valueId}`]?.data;
-    const classId = pending?.nodeType === "literal" ? pending.classId : isObjectRecord(stored) ? stored.classId : void 0;
-    const visited = /* @__PURE__ */ new Set();
-    let cursor = typeof classId === "string" ? classes.get(classId) : void 0;
-    while (cursor !== void 0 && !visited.has(cursor.id)) {
-      visited.add(cursor.id);
-      const memberId = cursor.schema[name];
-      if (memberId !== void 0) return computed.has(memberId);
-      cursor = cursor.extendsClassId === null || cursor.extendsClassId === void 0 ? void 0 : classes.get(cursor.extendsClassId);
+  return {
+    member: (memberId) => members.get(memberId),
+    schemaMember: (classId, schemaKey) => {
+      const visited = /* @__PURE__ */ new Set();
+      let cursor = classes.get(classId);
+      while (cursor !== void 0 && !visited.has(cursor.id)) {
+        visited.add(cursor.id);
+        const memberId = cursor.schema[schemaKey];
+        if (memberId !== void 0) return members.get(memberId);
+        cursor = cursor.extendsClassId === null ? void 0 : classes.get(cursor.extendsClassId);
+      }
+      return void 0;
     }
-    return false;
   };
 }
+function isComputedMember(walk, valueId, name) {
+  const pending = walk.registry.pendingValues.get(valueId);
+  const stored = walk.state[`value:${valueId}`]?.data;
+  const storedClassId = isObjectRecord(stored) ? stored.classId : void 0;
+  const classId = pending?.nodeType === "literal" ? pending.classId : storedClassId;
+  return typeof classId === "string" && walk.schema().schemaMember(classId, name)?.kind === "computed";
+}
 function resolveRootPathDialogueGroupCollectionValuesV4(args) {
-  let placements;
+  let walk;
   let rootValues;
   for (const record7 of args.records) {
     if (record7.recordKind !== "dialogue-group") continue;
@@ -156997,13 +157347,7 @@ function resolveRootPathDialogueGroupCollectionValuesV4(args) {
     if (rootValues === void 0) rootValues = rootSlotValueIds(args.state);
     const target = walkRootValuePath(
       spelled.slice(ROOT_PATH_PENDING_PREFIX.length),
-      args.state,
-      args.registry,
-      () => placements ??= prospectiveStoredValuePlacements(
-        args.state,
-        args.registry,
-        args.manifest
-      ),
+      walk ??= valuePathWalk(args),
       rootValues,
       (message) => args.registry.loweringFailures.push({
         message,
@@ -157017,7 +157361,6 @@ function resolveRootPathDialogueGroupCollectionValuesV4(args) {
           label: String(record7.fileFields.name)
         }
       }),
-      args.resolveVirtualPath,
       args.unavailableSlots
     );
     if (target !== null) record7.fileFields.collectionValueId = target;
@@ -157036,7 +157379,7 @@ function rootSlotValueIds(state) {
   }
   return values;
 }
-function walkRootValuePath(path, state, registry, placements, rootValues, fail2, resolveVirtualPath, unavailableSlots, subject = "collectionValue path", isComputed) {
+function walkRootValuePath(path, walk, rootValues, fail2, unavailableSlots, subject = "collectionValue path") {
   const segments = path.split(".");
   const slotName = segments[1];
   if (segments[0] !== "root" || slotName === void 0) {
@@ -157063,7 +157406,7 @@ function walkRootValuePath(path, state, registry, placements, rootValues, fail2,
     return null;
   }
   return walkValueSegments(
-    { state, registry, placements, resolveVirtualPath, isComputed },
+    walk,
     slotValueId,
     segments.slice(2),
     path,
@@ -157073,7 +157416,7 @@ function walkRootValuePath(path, state, registry, placements, rootValues, fail2,
 }
 function walkValueSegments(walk, startId, segments, path, subject, fail2) {
   let cursor = startId;
-  for (const segment of segments) {
+  for (const [index, segment] of segments.entries()) {
     const pending = walk.registry.pendingValues.get(cursor);
     const body = (pending?.nodeType === "literal" ? pending.value : void 0) ?? (isObjectRecord(walk.state[`value:${cursor}`]?.data) ? (walk.state[`value:${cursor}`]?.data).value : void 0);
     if (Array.isArray(body)) {
@@ -157084,12 +157427,21 @@ function walkValueSegments(walk, startId, segments, path, subject, fail2) {
     }
     if (!isObjectRecord(body)) {
       const initializer = pending !== void 0 ? pending.nodeType === "initializer" : isInitValueContent(walk.state[`value:${cursor}`]?.data);
-      if (initializer) {
+      if (initializer && walk.initBuiltSlots === "refuse") {
         fail2(
-          `${subject} ${path} stops before segment ${segment}: an init block constructs the row it reaches, so a path cannot name its members yet.`
+          `${subject} ${path} stops before segment ${segment}: an init block constructs the row it reaches, so a value cannot name its members. Bind it from a declaration instead.`
         );
         return null;
       }
+      if (initializer)
+        return constructedSlotId(
+          walk,
+          cursor,
+          segments.slice(index),
+          path,
+          subject,
+          fail2
+        );
       fail2(
         `${subject} ${path} stops before segment ${segment}: the row it reaches stores no single-valued members.`
       );
@@ -157101,7 +157453,7 @@ function walkValueSegments(walk, startId, segments, path, subject, fail2) {
     const direct = directBody && typeof bodyId === "string" && (walk.registry.pendingValues.has(bodyId) || storedChild?.recordKind === "value" && storedChild.recordId === bodyId && isObjectRecord(storedChild.data));
     const next = direct ? bodyId : walk.placements().childrenByParentValueId.get(cursor)?.get(segment)?.childValueId;
     if (typeof next !== "string") {
-      if (walk.isComputed?.(cursor, segment, walk) === true) {
+      if (isComputedMember(walk, cursor, segment)) {
         fail2(
           `\`${path}\` names a computed member, which has no row to reference.`
         );
@@ -157111,6 +157463,10 @@ function walkValueSegments(walk, startId, segments, path, subject, fail2) {
         const resolved = walk.resolveVirtualPath?.(startId, segments);
         if (resolved != null) return resolved;
       } catch (error) {
+        if (error instanceof SchemaSourceError) {
+          walk.registry.loweringFailures.push(error);
+          return null;
+        }
         fail2(
           `${subject} ${path} could not resolve its construction: ${error instanceof Error ? error.message : String(error)}`
         );
@@ -157125,6 +157481,66 @@ function walkValueSegments(walk, startId, segments, path, subject, fail2) {
   }
   return cursor;
 }
+function constructedSlotId(walk, rootId, segments, path, subject, fail2) {
+  const schema = walk.schema();
+  const placement = walk.placements().placementByChildValueId.get(rootId);
+  if (placement === void 0) {
+    fail2(
+      `${subject} ${path} reaches init-built row ${rootId}, which no row places.`
+    );
+    return null;
+  }
+  const rootMemberId = placement.memberId;
+  if (rootMemberId === null) {
+    fail2(
+      `${subject} ${path} reaches init-built row ${rootId}, which its parent's class declares no member for.`
+    );
+    return null;
+  }
+  let member = schema.member(rootMemberId);
+  const steps = [];
+  for (const segment of segments) {
+    if (member?.kind !== "class") {
+      fail2(
+        `${subject} ${path} stops before segment ${segment}: the row an init block builds there stores no single-valued members.`
+      );
+      return null;
+    }
+    const slot = schema.schemaMember(member.classId, segment);
+    if (slot === void 0) {
+      fail2(
+        `${subject} ${path} has no value at segment ${segment}: class ${member.classId} declares no such member.`
+      );
+      return null;
+    }
+    if (slot.kind === "computed") {
+      fail2(
+        `\`${path}\` names a computed member, which has no row to reference.`
+      );
+      return null;
+    }
+    steps.push({ schemaKey: segment, memberId: slot.id });
+    member = slot;
+  }
+  if (member !== void 0 && hasRowTargetKind(member)) {
+    fail2(
+      `${subject} ${path} names a ${member.kind} an init block builds, which has no row to check against until the push stores it.`
+    );
+    return null;
+  }
+  return constructedSlotValueId(rootId, steps);
+}
+function hasRowTargetKind(member) {
+  switch (member.kind) {
+    case "class":
+    case "list":
+    case "set":
+    case "dictionary":
+      return true;
+    default:
+      return false;
+  }
+}
 function prospectiveStoredValuePlacements(state, registry, manifest) {
   const records3 = new Map(
     Object.values(state).map((record7) => [
@@ -157185,9 +157601,11 @@ var ROOT_PROJECT_FIELDS2, ROOT_PATH_PENDING_PREFIX;
 var init_root_source = __esm({
   "src/project-source/root-source.ts"() {
     "use strict";
+    init_source_diagnostics();
     init_project_root();
     init_value_comparison();
     init_members();
+    init_virtual_instance_graph();
     init_value_sources();
     init_source_format();
     init_stored_value_placements();
@@ -160362,30 +160780,47 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     [...staticValues.records, ...memberDefaults.records, ...rootValues.records],
     staticMemberValueIds
   );
+  const sourceTextByUri = new Map(
+    sourceEntries.map((entry) => [entry.relPath, entry.source])
+  );
   let collectionBindings;
   const resolveVirtualPath = (rootId, segments) => {
-    if (collectionBindings === void 0) {
-      const candidate = /* @__PURE__ */ new Map();
-      for (const [key, record7] of Object.entries(rootPathResolutionState)) {
-        if (record7.file !== void 0 && isSchemaRecordKindV4(record7.recordKind) && !documentsByKey.has(key))
-          continue;
-        candidate.set(key, { ...record7, deleted: false });
-      }
-      for (const row of valueLowerRegistry.pendingValues.values()) {
-        candidate.set(`value:${row.id}`, {
-          recordKind: "value",
-          recordId: row.id,
-          contentHash: "",
-          deleted: false,
-          data: { id: row.id, ...encodeStoredValueRowFields(row) }
-        });
+    if (collectionBindings instanceof SchemaSourceError)
+      throw collectionBindings;
+    try {
+      if (collectionBindings === void 0) {
+        const candidate = /* @__PURE__ */ new Map();
+        for (const [key, record7] of Object.entries(rootPathResolutionState)) {
+          if (record7.file !== void 0 && isSchemaRecordKindV4(record7.recordKind) && !documentsByKey.has(key))
+            continue;
+          candidate.set(key, { ...record7, deleted: false });
+        }
+        for (const row of valueLowerRegistry.pendingValues.values()) {
+          candidate.set(`value:${row.id}`, {
+            recordKind: "value",
+            recordId: row.id,
+            contentHash: "",
+            deleted: false,
+            data: { id: row.id, ...encodeStoredValueRowFields(row) }
+          });
+        }
+        const document = readPulledProjectDocumentV4(candidate);
+        compilePulledProjectDocumentForEvaluationV4(document);
+        collectionBindings = new CollectionBindingMaterializer(document);
       }
-      const document = readPulledProjectDocumentV4(candidate);
-      compilePulledProjectDocumentForEvaluationV4(document);
-      collectionBindings = new CollectionBindingMaterializer(document);
+      const resolved = collectionBindings.resolvePath(rootId, segments);
+      return resolved;
+    } catch (error) {
+      const diagnostic = initializerRuntimeDiagnostic(
+        error,
+        valueLowerRegistry.initializerSites,
+        sourceTextByUri,
+        projectAnalysisV4
+      );
+      if (!hasAuthoredSourceFile(diagnostic.file)) throw error;
+      if (collectionBindings === void 0) collectionBindings = diagnostic;
+      throw diagnostic;
     }
-    const resolved = collectionBindings.resolvePath(rootId, segments);
-    return resolved;
   };
   const resolvedCollectionPaths = resolveRootPathCollectionValuesV4({
     manifest,
@@ -160470,7 +160905,8 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     state: rootPathResolutionState,
     resolveVirtualPath,
     unavailableSlots: rootValues.unavailableSlots,
-    registry: valueLowerRegistry
+    registry: valueLowerRegistry,
+    initBuiltSlots: "derive"
   });
   const resolvedDefaultKeys = resolveKeyReferenceMemberDefaultsV4({
     manifest,
@@ -160568,7 +161004,7 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     unavailableSlots: rootValues.unavailableSlots,
     registry: valueLowerRegistry
   });
-  if (collectionBindings !== void 0) {
+  if (collectionBindings !== void 0 && !(collectionBindings instanceof SchemaSourceError)) {
     const bindings = collectionBindings;
     const templateInitializer = (id2) => {
       const sourceValueId = bindings.rowForValue(id2)?.sourceValueId;
@@ -160808,9 +161244,6 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     changes.push(recordDeleteChange(recordState, recordFile));
   }
   appendCollectionEntryDeletes(workspace, reconstructed3, changes);
-  const sourceTextByUri = new Map(
-    sourceEntries.map((entry) => [entry.relPath, entry.source])
-  );
   const referenceFailures = drainValueReferenceObligationsV4(
     prospectiveState,
     manifest,
@@ -160828,11 +161261,16 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
         state: rootPathResolutionState,
         resolveVirtualPath,
         unavailableSlots: rootValues.unavailableSlots,
-        registry: valueLowerRegistry
+        registry: valueLowerRegistry,
+        initBuiltSlots: "refuse"
       })
     }
   );
   for (const failure of referenceFailures) {
+    if (failure instanceof SchemaSourceError) {
+      parseErrors.push(failure);
+      continue;
+    }
     const message = failure.code === void 0 ? failure.message : `${failure.code}: ${failure.message}`;
     parseErrors.push(
       new SchemaSourceError(
@@ -160846,7 +161284,11 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
   }
   reportPhase("record-diff-references", "Checking packed values\u2026");
   if (referenceFailures.length > 0) {
-    return refusedStatus(conflictedFiles, parseErrors, parseWarnings);
+    return refusedStatus(
+      conflictedFiles,
+      uniqueSourceErrors(parseErrors),
+      parseWarnings
+    );
   }
   if (valueLowerRegistry.initializerKeyPatches.size > 0) {
     authoredValueSeeds = settleInitializerKeyCode({
@@ -167475,9 +167917,10 @@ function completionItemsForResolution(snapshot, resolved, word) {
   }
   const memberType2 = neoScriptMemberLookupType(resolved.type);
   const owner = memberType2.kind === "named" ? snapshot.project.typeById.get(memberType2.typeId) : void 0;
-  return membersForType(snapshot, resolved.type).filter(
-    (symbol) => (resolved.symbol?.name !== "base" || isConcreteBaseMember(symbol)) && (owner === void 0 || isMemberCompletionAccessible(snapshot, owner, symbol))
-  ).map((symbol) => symbolCompletion(symbol, word, snapshot));
+  return membersForType(snapshot, resolved.type).filter((symbol) => {
+    const declaration = symbol.inheritedFrom === void 0 ? owner : snapshot.project.typeById.get(symbol.inheritedFrom.typeId) ?? owner;
+    return (resolved.symbol?.name !== "base" || isConcreteBaseMember(symbol)) && (declaration === void 0 || isMemberCompletionAccessible(snapshot, declaration, symbol));
+  }).map((symbol) => symbolCompletion(symbol, word, snapshot));
 }
 function isConcreteBaseMember(symbol) {
   return !symbol.id.startsWith("builtin:") && symbol.static !== true && symbol.abstract !== true && (symbol.kind === "function" || symbol.kind === "method" || symbol.computed === true);
@@ -167537,6 +167980,22 @@ function membersForType(snapshot, type) {
           } : {}
         };
       });
+    if (type.narrowedInterfaces) {
+      const names = new Set(members.map((member) => member.name));
+      for (const bound of Object.values(type.narrowedInterfaces)) {
+        for (const member of membersForType(snapshot, bound)) {
+          if (names.has(member.name)) continue;
+          names.add(member.name);
+          const owner = snapshot.project.typeById.get(bound.typeId);
+          members.push(
+            owner === void 0 || member.inheritedFrom !== void 0 ? member : {
+              ...member,
+              inheritedFrom: { typeId: owner.id, typeName: owner.name }
+            }
+          );
+        }
+      }
+    }
     if (named.kind === "class") {
       members = members.filter(
         (member) => member.name !== NEOSCRIPT_CLASS_ID_MEMBER
@@ -186224,16 +186683,17 @@ function generateInheritedPropertyInterfaceAdapters(ctx, classDef, genericEnv) {
         continue;
       }
       const source = `((${receiverType})this).${memberName}`;
-      const getter = isMemberWithEntries(member) && interfaceValueType.startsWith("NeoReadOnly") ? readExpression(
+      const getter = isMemberWithEntries(member) ? collectionReadExpression(
         ctx,
         member,
+        `node.Get<${neoMemberNodeType(member)}>("${escapeCSharpString(schemaKey)}")`,
         schemaKey,
-        neoMemberNodeType(member),
-        false,
-        receiverType,
+        resolveMemberById(ctx, member.entryMemberId, "entryMemberId"),
+        memberSavedForStorage(ctx, memberId, false, declarationClass.id),
         null,
         genericEnv,
-        declarationClass.id
+        interfaceValueType,
+        false
       ) : [`return (${interfaceValueType})(object)${source}!;`];
       const hasSetter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string";
       const adapter = [
@@ -190755,12 +191215,12 @@ function collectionGuardArguments(member, writeGuardMemberName) {
   const name = escapeCSharpString(writeGuardMemberName);
   return isReadOnlyMember(member) ? `, () => ThrowReadOnlyMembership("${name}"), () => true` : `, () => ThrowIfReadOnly("${name}"), () => IsReadOnly`;
 }
-function collectionReadExpression(ctx, member, getNode, schemaKey, entryMember, saved, writeGuardMemberName, genericEnv, collectionTypeOverride) {
+function collectionReadExpression(ctx, member, getNode, schemaKey, entryMember, saved, writeGuardMemberName, genericEnv, collectionTypeOverride, genericBindingSaved = saved) {
   const keyCodecArguments = dictionaryKeyCodecArguments(ctx, member);
   if (saved) {
     const entrySaved = collectionEntrySaved(member, entryMember, true);
     const writableNodeType = isMemberDictionaryBase(member) ? "NeoMemberDictionaryWritable" : "NeoMemberListWritable";
-    const collectionType2 = collectionTypeOverride ?? csharpValueType(ctx, member, true, genericEnv);
+    const collectionType2 = collectionTypeOverride ?? csharpValueType(ctx, member, true, genericEnv, genericBindingSaved);
     const keyLiteral = `"${escapeCSharpString(schemaKey)}"`;
     const readNode = `writableNode.Get<${writableNodeType}>(${keyLiteral})`;
     const guardArguments = collectionGuardArguments(
@@ -190772,13 +191232,14 @@ function collectionReadExpression(ctx, member, getNode, schemaKey, entryMember,
       entryMember,
       readNode,
       member.name,
-      genericEnv
+      genericEnv,
+      genericBindingSaved
     );
     return cachedStoredWrapper(
       schemaKey,
       readNode,
       collectionType2 ?? "object",
-      `new ${collectionType2}(client, memberNode, () => writableNode.GetOrCreateCollection<${writableNodeType}>(${keyLiteral}), (client, child) => ${childConverter(ctx, entryMember, entrySaved, entrySaved && writeGuardMemberName != null, genericEnv)}, item => ${serializeExpression}${keyCodecArguments}${guardArguments})`
+      `new ${collectionType2}(client, memberNode, () => writableNode.GetOrCreateCollection<${writableNodeType}>(${keyLiteral}), (client, child) => ${childConverter(ctx, entryMember, entrySaved, entrySaved && writeGuardMemberName != null, genericEnv, genericBindingSaved)}, item => ${serializeExpression}${keyCodecArguments}${guardArguments})`
     );
   }
   const collectionType = collectionTypeOverride ?? csharpValueType(ctx, member, false, genericEnv);
@@ -190900,9 +191361,9 @@ function interfaceValueRead(ctx, member, nodeExpression, readOnly, genericEnv) {
   if (!isRequiredMember(member)) return read;
   return `${read} ?? throw new InvalidOperationException("Required '${escapeCSharpString(member.name)}' holds no class value.")`;
 }
-function entrySerializeExpression(ctx, entryMember, collectionNode, slotLabel2, genericEnv) {
+function entrySerializeExpression(ctx, entryMember, collectionNode, slotLabel2, genericEnv, genericBindingSaved = true) {
   const throughCodec = entryMember !== null && (isMemberGenericBase(entryMember) || isMemberLookupBase(entryMember) && lookupProjection(ctx, entryMember) !== "class" /* Class */);
-  return throughCodec ? `NeoGenericBindings.Resolve<${csharpValueType(ctx, entryMember, true, genericEnv) ?? "object"}>(client, ${collectionNode}).Serialize(item)` : serializeItemExpression(ctx, entryMember, "item", slotLabel2);
+  return throughCodec ? `NeoGenericBindings.Resolve<${csharpValueType(ctx, entryMember, true, genericEnv, genericBindingSaved) ?? "object"}>(client, ${collectionNode}).Serialize(item)` : serializeItemExpression(ctx, entryMember, "item", slotLabel2);
 }
 function lookupSelectionFactory(ctx, member, selection2, saved, writeGuardMemberName, genericEnv) {
   const targetSaved = lookupTargetSaved(ctx, member) ?? saved;
@@ -191018,7 +191479,7 @@ function dialogueLookupReadExpression(member, getNode, saved, writeGuardMemberNa
     "return selected is null ? null : new NeoDialogueReference(client, selected);"
   ];
 }
-function childConverter(ctx, member, saved = false, branchOnReadOnly = false, genericEnv) {
+function childConverter(ctx, member, saved = false, branchOnReadOnly = false, genericEnv, genericBindingSaved = saved) {
   if (member === null) return "throw new NotSupportedException()";
   if (isMemberDelegateBase(member)) {
     const delegateType = csharpDelegateType(ctx, member, saved, genericEnv) ?? "NeoDelegate<object?>";
@@ -191040,7 +191501,13 @@ function childConverter(ctx, member, saved = false, branchOnReadOnly = false, ge
     return `((NeoMemberAction)child).Bind${actionBindTypeArguments(actionType)}()`;
   }
   if (isMemberGenericBase(member)) {
-    const paramType = csharpValueType(ctx, member, saved, genericEnv);
+    const paramType = csharpValueType(
+      ctx,
+      member,
+      saved,
+      genericEnv,
+      genericBindingSaved
+    );
     if (paramType === null) return "throw new NotSupportedException()";
     return `NeoGenericBindings.Resolve<${paramType}>(client, (NeoMember)child).Read((NeoMember)child)`;
   }
@@ -194671,7 +195138,7 @@ var UNITY_CODEGEN_REVISION;
 var init_unity_codegen_revision = __esm({
   "../src/models/exports/unity-codegen-revision.ts"() {
     "use strict";
-    UNITY_CODEGEN_REVISION = "231557c5a40a20ab9e630415d45556845d7561d54e335a4d92c1cdbc1024a705";
+    UNITY_CODEGEN_REVISION = "e875228ee779f868c2c818eb9e245604cd074598712ffd3f8394f460317b1a28";
   }
 });
 
@@ -215809,7 +216276,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.84.1");
+    console.log("0.84.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {