@neocompose/cli 0.84.2 → 0.84.4

package/dist/neo-runtime.mjs

@@ -3100,14 +3100,14 @@ function isNSFunctionContains(value) {
   if (v?.type !== "contains" /* contains */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 function isNSFunctionIndexOf(value) {
   const v = value;
   if (v?.type !== "indexOf" /* indexOf */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 function isNSFunctionStringOp(value) {
   const v = value;
@@ -3255,7 +3255,7 @@ function isNSFunctionCollectionQuery(value) {
     case "Reverse":
       return true;
     case "ToSet":
-      return info.reference === void 0 || info.reference === true;
+      return (info.reference === void 0 || info.reference === true) && (info.decimalEntries === void 0 || info.decimalEntries === true);
     default:
       return false;
   }
@@ -17587,7 +17587,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.84.2",
+      cliVersion: "0.84.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -26056,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);
 }
@@ -26952,7 +26968,7 @@ function typeInfoConstructedSuffix(ctx, typeInfo, saved, genericEnv, genericBind
     const argType = csharpTypeInfoValueType(
       ctx,
       argInfo,
-      saved,
+      true,
       genericEnv,
       genericBindingSaved
     );
@@ -42179,7 +42195,7 @@ var init_strict_resolver = __esm({
             scope
           )
         );
-        const schemaClassInfo = toWireType(targetType, this.project);
+        const schemaClassInfo = this.constructorWireType(targetType, expression);
         if (schemaClassInfo.type !== 7 /* Class */) {
           throw new Error(
             `NeoScript constructor ${className} has non-Class return type ${this.describe(signature.returnType)}.`
@@ -42197,6 +42213,16 @@ var init_strict_resolver = __esm({
           writability: "session" /* Session */
         };
       }
+      /** Constructor storage arguments stay distinct from their expression read types. */
+      constructorWireType(target, expression) {
+        const typeArguments = expression.typeArguments?.map(
+          (argument2) => resolveStoredReferenceTarget(argument2, this.context, this.project)
+        );
+        return toWireType(
+          typeArguments === void 0 ? target : { ...target, typeArguments },
+          this.project
+        );
+      }
       constructorTargetType(schemaClass2, expression, expected) {
         const typeArguments = expression.typeArguments?.map(
           (argument2) => this.resolveType(argument2)
@@ -42327,7 +42353,7 @@ var init_strict_resolver = __esm({
           scope
         );
         const classType = targetType;
-        const schemaClassInfo = toWireType(classType, this.project);
+        const schemaClassInfo = this.constructorWireType(classType, expression);
         if (schemaClassInfo.type !== 7 /* Class */) {
           throw new Error(
             `NeoScript declared constructor ${className} projected a non-Class wire type.`
@@ -43190,6 +43216,8 @@ var init_strict_resolver = __esm({
             {
               collectionPointer: receiver.pointer,
               valuePointer: value.pointer,
+              ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+              ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
               ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
             },
             { kind: "primitive", name: "int" }
@@ -43219,6 +43247,8 @@ var init_strict_resolver = __esm({
             {
               collectionPointer: receiver.pointer,
               valuePointer: value.pointer,
+              ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+              ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
               ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
             },
             { kind: "primitive", name: "bool" }
@@ -43451,6 +43481,7 @@ var init_strict_resolver = __esm({
             info = {
               ...base,
               op: name,
+              ...isPrimitive(collection.valueType, "decimal") ? { decimalEntries: true } : {},
               ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
             };
             resultType = {
@@ -52165,7 +52196,9 @@ function subscriptKeyType(receiver) {
   return void 0;
 }
 function validateReferenceExpression(expression, declared, scope, environment, uri, range2, diagnostics) {
-  const expected = declared?.name === "NeoDialogueReference" ? { ...declared, name: "NeoDialogue" } : declared;
+  let expected = declared?.name === "Reference" ? declared.arguments?.[0] : declared;
+  if (expected?.name === "NeoDialogueReference")
+    expected = { ...expected, name: "NeoDialogue" };
   const typeArguments = expression.typeArguments ?? [];
   const names = expression.argumentNames ?? [];
   const idIndex = names.findIndex((name) => name === "id");
@@ -79236,16 +79269,18 @@ var init_runtime_set = __esm({
   "../packages/neoscript-runtime/src/neoscript/runtime-set.ts"() {
     "use strict";
     RuntimeSet = class {
-      constructor(source, reference2, enumEntries, slotReferences = null) {
+      constructor(source, reference2, enumEntries, slotReferences = null, decimalEntries = false) {
         this.source = source;
         this.reference = reference2;
         this.enumEntries = enumEntries;
         this.slotReferences = slotReferences;
+        this.decimalEntries = decimalEntries;
       }
       source;
       reference;
       enumEntries;
       slotReferences;
+      decimalEntries;
       entries = /* @__PURE__ */ new Map();
       validations = /* @__PURE__ */ new Map();
       snapshot;
@@ -79255,6 +79290,9 @@ var init_runtime_set = __esm({
       has(key) {
         return this.entries.has(key);
       }
+      *values() {
+        for (const entry of this.entries.values()) yield entry.raw;
+      }
       add(key, raw, reference2) {
         if (this.entries.has(key)) return;
         this.entries.set(key, { raw, reference: reference2 });
@@ -82723,6 +82761,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) {
@@ -82730,83 +82769,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;
@@ -82857,7 +82947,14 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
   for (let index = 0; index < argumentValues.length; index += 1) {
     const parameter4 = parameters[index];
     if (parameter4 === void 0) continue;
-    scope.setLocal(parameter4.id, argumentValues[index]);
+    scope.setLocal(
+      parameter4.id,
+      coerceAssignmentValue(
+        argumentValues[index],
+        parameter4.typeInfo,
+        "getter argument"
+      )
+    );
   }
   try {
     const result = evalBody(
@@ -82867,9 +82964,11 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
       evaluationOptions(runtimeCtx, false)
     );
     if (result.kind === "return") {
-      if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
-        result.value = coerceDecimalOperand(result.value, "return");
-      }
+      result.value = coerceAssignmentValue(
+        result.value,
+        getter.typeInfo,
+        "return"
+      );
       if (ownsInvocationState) {
         flushRuntimeSets(runtimeCtx);
         result.value = exportRuntimeSetValue(result.value, runtimeCtx);
@@ -83704,7 +83803,11 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     const parameter4 = action.parameters[index + 2];
     const runtimeTypeInfo = runtimeArgumentTypes[index];
     const value2 = asDeclaredRuntimeSet(
-      restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+      coerceAssignmentValue(
+        restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+        runtimeTypeInfo,
+        "function argument"
+      ),
       runtimeTypeInfo,
       ctx
     );
@@ -83738,9 +83841,7 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     }
     return null;
   }
-  if (runtimeReturnType.type === 20 /* Decimal */ && typeof value === "number") {
-    value = coerceDecimalOperand(value, "function return");
-  }
+  value = coerceAssignmentValue(value, runtimeReturnType, "function return");
   if (!runtimeValueMatchesType(value, runtimeReturnType, ctx)) {
     throw new NSGetterRuntimeError(
       "NSFunction returned a value that does not match its compiled return type."
@@ -84079,9 +84180,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "variable" /* variable */: {
           let value = evalPointer(ins.variable.pointer, scope, ctx);
-          if (ins.variable.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "variable initialization");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.variable.typeInfo,
+            "variable initialization"
+          );
           value = asDeclaredRuntimeSet(value, ins.variable.typeInfo, ctx);
           scope.setLocal(ins.variable.id, value);
           break;
@@ -84117,9 +84220,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "assign" /* assign */: {
           let value = evalPointer(ins.pointer, scope, ctx);
-          if (ins.target.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "assignment");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.target.typeInfo,
+            "assignment"
+          );
           if (ins.target.pointer.type === "variable" /* variable */) {
             assertVariableBindingWritable(scope, ins.target.pointer.variableId);
             scope.setLocal(ins.target.pointer.variableId, value);
@@ -85893,6 +85998,21 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
+  const decimalEntries = "entryTypeInfo" in ins.target.typeInfo && ins.target.typeInfo.entryTypeInfo.type === 20 /* Decimal */;
+  let entryArgumentIndex = null;
+  const dictionary = ins.target.typeInfo.type === 5 /* Dictionary */;
+  if (ins.mutation === "Add" /* Add */)
+    entryArgumentIndex = dictionary ? 1 : 0;
+  if (ins.mutation === "Insert" /* Insert */) entryArgumentIndex = 1;
+  if (ins.mutation === "Remove" /* Remove */ && !dictionary)
+    entryArgumentIndex = 0;
+  if (entryArgumentIndex !== null && "entryTypeInfo" in ins.target.typeInfo) {
+    args[entryArgumentIndex] = coerceAssignmentValue(
+      args[entryArgumentIndex],
+      ins.target.typeInfo.entryTypeInfo,
+      "collection mutation entry"
+    );
+  }
   const setEntryMember = mutatesLocalVariable ? null : storedSetEntryMember(targetValue, ctx);
   const isLookupSet = setEntryMember === null && ins.target.typeInfo.type === 9 /* Lookup */;
   if (isLookupSet && Array.isArray(targetValue)) {
@@ -85900,7 +86020,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       targetValue,
       ins.reference === true,
       ins.target.typeInfo.type === 9 /* Lookup */ && (ins.target.typeInfo.entryTypeInfo.type === 8 /* Enum */ || ins.target.typeInfo.entryTypeInfo.type === 18 /* DialogueLookup */),
-      ctx
+      ctx,
+      decimalEntries
     );
   }
   const setMatch = setEntryMember !== null && Array.isArray(targetValue) && (ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) ? findStoredSetEntry(targetValue, args[0], setEntryMember, ctx) : null;
@@ -85919,7 +86040,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       ctx,
       isLookupSet,
       false,
-      ins.reference === true
+      ins.reference === true,
+      decimalEntries
     );
     updateCollectionReferenceProvenance(
       targetValue,
@@ -85997,7 +86119,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     ctx,
     isLookupSet,
     ins.reference !== true && ins.mutation === "Remove" /* Remove */ && isArrayCollection(targetValue) && setEntryMember === null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null,
-    ins.reference === true
+    ins.reference === true,
+    setEntryMember === null && decimalEntries
   );
   updateCollectionReferenceProvenance(
     targetValue,
@@ -86273,21 +86396,28 @@ function asDeclaredRuntimeSet(value, type, ctx) {
     value,
     entry === 7 /* Class */ || entry === 22 /* Interface */ || entry === 6 /* List */ || entry === 5 /* Dictionary */ || entry === 9 /* Lookup */,
     entry === 8 /* Enum */ || entry === 18 /* DialogueLookup */,
-    ctx
+    ctx,
+    entry === 20 /* Decimal */
   );
 }
 function runtimeSetKey(value, set, ctx) {
   if (set.slotReferences !== null) return slotReferenceKey(value);
   if (set.enumEntries && Array.isArray(value) && value.length === 1)
     value = value[0];
-  return toSetEntryKey(value, null, set.reference, ctx);
+  return toSetEntryKey(value, null, set.reference, ctx, set.decimalEntries);
 }
-function runtimeSet(array3, reference2, enumEntries, ctx) {
+function runtimeSet(array3, reference2, enumEntries, ctx, decimalEntries = false) {
   const sets = ctx.__runtimeSets ??= /* @__PURE__ */ new WeakMap();
   ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set();
   const existing = sets.get(array3);
   if (existing !== void 0) return existing;
-  const set = new RuntimeSet(array3, reference2, enumEntries);
+  const set = new RuntimeSet(
+    array3,
+    reference2,
+    enumEntries,
+    null,
+    decimalEntries
+  );
   const references = collectionReferences(array3, ctx);
   for (let index = 0; index < array3.length; index++) {
     const raw = array3[index];
@@ -86406,7 +86536,7 @@ function removableEntryRowIds(targetValue, mutation, args, ctx) {
   }
   return rowIds;
 }
-function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference2 = false) {
+function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference2 = false, decimal2 = false) {
   if (targetValue instanceof RuntimeSet) {
     (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(targetValue);
     switch (mutation) {
@@ -86458,6 +86588,7 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
         const references = resolveRemovalEntries ? collectionReferences(targetValue, ctx) : recordedReferenceEntries(targetValue, ctx) ?? 1 /* Values */;
+        const targetKey = decimal2 ? decimalCollectionKey(args[0]) : args[0];
         let index = -1;
         for (let candidate = 0; candidate < targetValue.length; candidate += 1) {
           const entry = targetValue[candidate];
@@ -86468,10 +86599,8 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
             }
             continue;
           }
-          if (jsEqual(
-            typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry,
-            args[0]
-          )) {
+          const value = typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry;
+          if (jsEqual(decimal2 ? decimalCollectionKey(value) : value, targetKey)) {
             index = candidate;
             break;
           }
@@ -86958,12 +87087,22 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
     case "function" /* function */:
       return evalFunction(pointer.function, scope, ctx);
     case "listLiteral" /* listLiteral */:
-      return pointer.entries.map((e) => evalPointer(e, scope, ctx));
+      return pointer.entries.map(
+        (entry) => coerceAssignmentValue(
+          evalPointer(entry, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "list entry"
+        )
+      );
     case "dictLiteral" /* dictLiteral */: {
       const out = {};
       for (const e of pointer.entries) {
         const k = evalPointer(e.key, scope, ctx);
-        out[String(k)] = evalPointer(e.value, scope, ctx);
+        out[String(k)] = coerceAssignmentValue(
+          evalPointer(e.value, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "dictionary entry"
+        );
       }
       return out;
     }
@@ -88625,9 +88764,9 @@ function readRecordKey(receiver, k, memberId, ctx) {
     if (receiver === ctx.thisValue && typeof ctx.thisValueRowId === "string") {
       return ctx.thisValueRowId;
     }
-    const rowId = findKnownRowIdByValueReference(receiver, ctx);
-    if (rowId) return rowId;
-    throw new NSGetterRuntimeError("Class value has no backing row id.");
+    const row = trackedRowForValueReference(receiver, ctx);
+    if (row !== null && classIdForValueRow(row, ctx) !== void 0)
+      return row.id;
   }
   const assetMember = resolveAssetRuntimeMember(receiver, k, ctx);
   if (assetMember.kind === "ok") return assetMember.value;
@@ -89925,7 +90064,11 @@ function evalDecimalMathOp(info, fn, scope, ctx) {
   }
 }
 function evalListRepeat(info, scope, ctx) {
-  const value = evalPointer(info.valuePointer, scope, ctx);
+  const value = coerceAssignmentValue(
+    evalPointer(info.valuePointer, scope, ctx),
+    info.entryTypeInfo,
+    "List.Repeat entry"
+  );
   const count = numberArg(
     evalPointer(info.countPointer, scope, ctx),
     "List.Repeat count"
@@ -90013,13 +90156,18 @@ function jsEqual(a, b) {
     return a instanceof NSSlotReference && b instanceof NSSlotReference && a.targetId === b.targetId;
   }
   if (a === b) return true;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i2 = 0; i2 < a.length; i2++) {
-      if (!jsEqual(a[i2], b[i2])) return false;
+  if (Array.isArray(a) || a instanceof RuntimeSet) {
+    if (!Array.isArray(b) && !(b instanceof RuntimeSet)) return false;
+    const aSize = a instanceof RuntimeSet ? a.size : a.length;
+    const bSize = b instanceof RuntimeSet ? b.size : b.length;
+    if (aSize !== bSize) return false;
+    const other = b.values();
+    for (const entry of a.values()) {
+      if (!jsEqual(entry, other.next().value)) return false;
     }
     return true;
   }
+  if (b instanceof RuntimeSet) return false;
   if (typeof a === "object" && typeof b === "object" && a !== null && b !== null && !Array.isArray(a) && !Array.isArray(b)) {
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
@@ -90455,7 +90603,8 @@ function evalCollectionQuery(info, scope, ctx) {
       output,
       info.reference === true,
       info.enumEntries === true,
-      ctx
+      ctx,
+      info.decimalEntries === true
     ) : output;
   };
   if (info.op === "OrderBy" || info.op === "OrderByDescending") {
@@ -90507,7 +90656,8 @@ function evalCollectionQuery(info, scope, ctx) {
           entry,
           valueId,
           info.reference === true,
-          ctx
+          ctx,
+          info.decimalEntries === true
         );
         if (seenSetKeys.has(setKey)) return 0 /* Continue */;
         seenSetKeys.add(setKey);
@@ -90562,10 +90712,15 @@ function evalCollectionQuery(info, scope, ctx) {
   }
   return finish();
 }
-function toSetEntryKey(entry, valueId, reference2, ctx) {
+function toSetEntryKey(entry, valueId, reference2, ctx, decimal2 = false) {
   if (reference2) return valueId ?? referenceIdOf(entry, ctx) ?? entry;
+  if (decimal2) return decimalCollectionKey(entry);
   return typeof entry === "object" && entry !== null ? canonicalJsonStringify(entry) : entry;
 }
+function decimalCollectionKey(value) {
+  if (value === null) return null;
+  return decimalKey(coerceDecimalOperand(value, "decimal collection entry"));
+}
 function compareCollectionKeys(left, right, keyType) {
   if (left === null) return right === null ? 0 : -1;
   if (right === null) return 1;
@@ -90683,7 +90838,11 @@ function evalFunction(fn, scope, ctx) {
     }
     case "contains" /* contains */: {
       let c = evalPointer(fn.info.collectionPointer, scope, ctx);
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
+      if (fn.info.decimal === true && target !== null)
+        target = coerceDecimalOperand(target, "collection search");
       if (typeof c === "string") {
         if (typeof target !== "string") {
           throw new NSGetterRuntimeError(
@@ -90716,9 +90875,13 @@ function evalFunction(fn, scope, ctx) {
         return referenceIndexOf(c, target, ctx) !== null;
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let containsResolvedEntry = false;
       iterateCollection(c, ctx, (entry, _key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           containsResolvedEntry = true;
           return 1 /* Break */;
         }
@@ -90731,15 +90894,21 @@ function evalFunction(fn, scope, ctx) {
         evalPointer(fn.info.collectionPointer, scope, ctx),
         "IndexOf receiver"
       );
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
       if (fn.info.reference === true) {
         const index = referenceIndexOf(collection, target, ctx);
         return index === null ? -1 : numberArg(index, "IndexOf index");
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let found = -1;
       iterateCollection(collection, ctx, (entry, key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           found = numberArg(key, "IndexOf index");
           return 1 /* Break */;
         }
@@ -90947,7 +91116,19 @@ function evalFunction(fn, scope, ctx) {
         );
         iterateCollection(c, ctx, callback);
       }
-      if (found !== sentinel) return found;
+      if (found !== sentinel) {
+        if (typeof found === "string") {
+          if (c instanceof RuntimeSet) {
+            if (c.enumEntries) return [found];
+          } else {
+            const row = trackedRowForValueReference(c, ctx);
+            const member = row === null ? null : memberForValueRow(row, ctx);
+            if (member?.kind === 8 /* Enum */ || member?.kind === 18 /* DialogueLookup */)
+              return [found];
+          }
+        }
+        return found;
+      }
       if (fn.type === "first" /* first */) {
         throw new NSGetterRuntimeError(
           innerFn ? "First() found no matching entry. Use FirstOrDefault() and handle null if no match is expected." : "First() called on an empty collection. Check that it has entries, or use FirstOrDefault() and handle null."
@@ -92160,10 +92341,19 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
     }
     return null;
   };
+  const defaultScopeMemberId = (memberId) => walkExtendsMemberChain(
+    memberId,
+    ctx.vm.members,
+    (declaration) => declaration.defaultValue === void 0 ? void 0 : declaration.id,
+    {
+      memberById: (id2) => indexes4.schemaIndex.member(id2) ?? null,
+      maxHops: ctx.vm.members.length
+    }
+  );
   return (member, init, sourceValueId, genericEnv = instanceEnv) => {
     const memberId = Reflect.get(member, "id");
     const effectiveMemberId = typeof memberId === "string" ? memberId : null;
-    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? effectiveMemberId;
+    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? (sourceValueId === void 0 && effectiveMemberId !== null ? defaultScopeMemberId(effectiveMemberId) : void 0) ?? effectiveMemberId;
     const compiled = ensureInitializerCompiled({
       init,
       member,
@@ -94159,6 +94349,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));
   }
@@ -96204,7 +96395,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
               ];
             }
           )
@@ -96240,6 +96431,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)) {
@@ -98147,7 +98373,11 @@ function resolveVirtualInstanceGraph(args) {
         }
       }
     }
-    const virtualRow = rewriteExpandedRow(indexed, expansion);
+    const virtualRow = rewriteExpandedRow(
+      indexed,
+      expansion,
+      materializedGraph
+    );
     const location3 = {
       id: effectiveId2,
       instanceRootId: args.instanceRoot.id,
@@ -99601,6 +99831,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({
@@ -99632,10 +99872,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);
@@ -99734,6 +99971,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);
@@ -99856,6 +100095,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]),
@@ -100122,7 +100379,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;
@@ -100144,6 +100401,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);
   }
@@ -100360,6 +100623,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);
@@ -118701,21 +118976,25 @@ function projectValueHeadPlacementGraph(args) {
       );
     return { ...substituteMember(member, bindings, genericMembers, member) };
   };
-  const instanceBindings = (classId, member) => {
+  const instanceBindings = (classId, member, value) => {
     if (classId === null || !genericClassIds.has(classId)) return emptyBindings;
-    if (isInterfaceTypedMember(member)) {
-      return resolveInstanceEnv(
-        classId,
-        slotClassArguments(member, classId, implementerIndex()),
-        genericClasses
-      );
-    }
-    const arguments_ = member.classArguments;
+    const arguments_ = isInterfaceTypedMember(member) ? slotClassArguments(member, classId, implementerIndex()) : member.classArguments;
     if (arguments_ != null && !isGenericBindingsRecord(arguments_))
       throw new Error(
         `Class placement "${classId}" has malformed generic arguments.`
       );
-    return resolveInstanceEnv(classId, arguments_, genericClasses);
+    const env = resolveInstanceEnv(classId, arguments_, genericClasses);
+    const stamp = value?.genericBindings;
+    if (stamp !== void 0) {
+      if (!isStringRecord7(stamp))
+        throw new Error(
+          `Class value "${String(value?.id)}" has malformed genericBindings.`
+        );
+      for (const [paramId, entry] of envFromStamp(stamp))
+        env.set(paramId, entry);
+      closeForwardedGenericParams(env);
+    }
+    return env;
   };
   const unorderedByContainer = /* @__PURE__ */ new Map();
   for (const value of values.values()) {
@@ -118860,7 +119139,7 @@ function projectValueHeadPlacementGraph(args) {
     }
     result.set(item.valueId, projection);
     args.contextualMembers?.set(item.valueId, member);
-    const childBindings = classId === null ? item.bindings ?? emptyBindings : instanceBindings(classId, member);
+    const childBindings = classId === null ? item.bindings ?? emptyBindings : instanceBindings(classId, member, value);
     if ((member.kind === 5 /* Dictionary */ || member.kind === 6 /* List */ || member.kind === 28 /* Set */) && childBindings.size > 0) {
       if (!isMemberBase(member))
         throw new Error(
@@ -119060,6 +119339,9 @@ function joinPath(parent, child2) {
 function placementsEqual(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
+function isStringRecord7(value) {
+  return isRecord6(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -123909,6 +124191,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();
@@ -123925,6 +124208,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();
@@ -123982,17 +124266,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);
@@ -124006,6 +124293,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;
       }
     };
@@ -124214,6 +124508,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) {
@@ -124297,6 +124627,61 @@ var init_stored_closure_captures = __esm({
   }
 });
 
+// ../src/database/construction-replay-equality.ts
+function createConstructionReplayComparer(reader, ownedValueIds) {
+  let graph;
+  return (args) => {
+    if (!isLiteralValueContent(args.currentRoot)) return false;
+    if (!isLiteralValueContent(args.replayRoot)) return false;
+    if (args.currentRoot.instanceConstructorId !== args.replayRoot.instanceConstructorId)
+      return false;
+    const replayArgs = args.replayRoot.constructorArgs;
+    if (replayArgs === void 0 || replayArgs === null) return true;
+    if (args.currentArguments === void 0 || args.currentArguments === null)
+      return false;
+    graph ??= new MaterializedValueGraphContext(reader.documentView);
+    let owned;
+    for (const edge of graph.constructorEdges(
+      args.currentRoot,
+      args.rootMember
+    )) {
+      const replayed2 = replayArgs[edge.parameterId];
+      if (replayed2 === edge.targetValueId) continue;
+      if (typeof replayed2 === "string" && !args.replayRows.has(replayed2))
+        return false;
+      owned ??= new Set(ownedValueIds(args.currentRoot, args.rootMember));
+      if (!owned.has(edge.targetValueId)) return false;
+    }
+    const stored = { ...args.currentArguments };
+    const replayed = { ...replayArgs };
+    for (const [slot, value] of Object.entries(stored)) {
+      if (typeof value !== "string" || replayed[slot] !== value) continue;
+      delete stored[slot];
+      delete replayed[slot];
+    }
+    return effectiveValuesEqual(
+      reader.normalizeConstructorArguments(
+        stored,
+        args.currentRoot,
+        args.rootMember
+      ),
+      reader.withRowOverrides(args.replayRows).normalizeConstructorArguments(
+        replayed,
+        args.replayRoot,
+        args.rootMember
+      )
+    );
+  };
+}
+var init_construction_replay_equality = __esm({
+  "../src/database/construction-replay-equality.ts"() {
+    "use strict";
+    init_effective_value_comparison();
+    init_constructor_argument_ownership();
+    init_members();
+  }
+});
+
 // ../src/models/project/world-layer-compatibility-error.ts
 var WorldLayerCompatibilityError;
 var init_world_layer_compatibility_error = __esm({
@@ -126304,9 +126689,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;
   }
@@ -127942,8 +128327,7 @@ function materializePreparedInstanceInitializers(args) {
     compiledDocument,
     compiledDocument.variants ?? []
   );
-  let currentReader = null;
-  const requireCurrentReader = () => currentReader ??= new EffectiveValueReader(materializationScope.document);
+  let compareConstruction;
   let ownedValueCollector;
   let valueHashes;
   const liveValueHashes = () => valueHashes ??= indexLiveContentHashesByRecordId(
@@ -127961,6 +128345,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) {
@@ -128008,16 +128393,28 @@ function materializePreparedInstanceInitializers(args) {
           `construction-arguments-conflict: Value "${valueId}" is already materialized as class "${String(existingConstructedRoot.classId)}", and this construction builds class "${String(materialized.root.classId)}". Delete and recreate the value to change its class.`
         );
       }
-      if (replayedCreationDataMatches({
-        // The synthetic variant binding members are part of the ownership
-        // scope that compiled and evaluated this initializer. Stored replay
-        // closes its generic slot from the same ephemeral member id, so its
-        // expansion must read that scoped document too.
-        currentReader: requireCurrentReader(),
+      compareConstruction ??= createConstructionReplayComparer(
+        new EffectiveValueReader(materializationScope.document),
+        (root, rootMember) => {
+          ownedValueCollector ??= createOwnedValueDeletionCollector(
+            args.document
+          );
+          return ownedValueCollector.collect({
+            rootIds: [root.id],
+            rootMembers: /* @__PURE__ */ new Map([[root.id, rootMember]])
+          });
+        }
+      );
+      const replayRows = new Map(
+        materialized.createdValues.map((row) => [row.id, row])
+      );
+      replayRows.set(materialized.root.id, materialized.root);
+      if (compareConstruction({
         currentRoot: existingConstructedRoot,
+        currentArguments: isLiteralValueContent(existingConstructedRoot) ? existingConstructedRoot.constructorArgs : void 0,
         rootMember: member,
         replayRoot: materialized.root,
-        replayCreated: materialized.createdValues
+        replayRows
       })) {
         replayOnlyIndexes.push(site.index);
         batch.upsert([existingConstructedRoot]);
@@ -128050,7 +128447,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,
@@ -128137,46 +128535,6 @@ function materializePreparedInstanceInitializers(args) {
     args.prepared.splice(index, 1);
   }
 }
-function replayedCreationDataMatches(args) {
-  if (!isLiteralValueContent(args.currentRoot) || !isLiteralValueContent(args.replayRoot)) {
-    return false;
-  }
-  const replayArgs = args.replayRoot.constructorArgs;
-  if (replayArgs !== void 0 && replayArgs !== null) {
-    const currentArgs = args.currentRoot.constructorArgs;
-    if (currentArgs === void 0 || currentArgs === null || !constructorArgumentsSemanticallyEqual({
-      currentReader: args.currentReader,
-      currentRoot: args.currentRoot,
-      rootMember: args.rootMember,
-      current: currentArgs,
-      replayRoot: args.replayRoot,
-      replayCreated: args.replayCreated,
-      replay: replayArgs
-    })) {
-      return false;
-    }
-  }
-  return true;
-}
-function constructorArgumentsSemanticallyEqual(args) {
-  const current = args.currentReader;
-  const replayRows = /* @__PURE__ */ new Map([
-    [args.replayRoot.id, args.replayRoot]
-  ]);
-  for (const row of args.replayCreated) replayRows.set(row.id, row);
-  const replay = current.withRowOverrides(replayRows);
-  const currentNormalized = current.normalizeConstructorArguments(
-    args.current,
-    args.currentRoot,
-    args.rootMember
-  );
-  const replayNormalized = replay.normalizeConstructorArguments(
-    args.replay,
-    args.replayRoot,
-    args.rootMember
-  );
-  return effectiveValuesEqual(currentNormalized, replayNormalized);
-}
 function completeLocalizedTextCreateEnvelopes(args) {
   const createsLocalizedText = args.changes.some(
     (change) => change.recordKind === "localized-text" && change.operation === "create"
@@ -131217,9 +131575,10 @@ 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();
+    init_construction_replay_equality();
     init_classes();
     init_constructor_parameter_settlement();
     init_generics();
@@ -137709,7 +138068,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: isPlainRecord8(value.system) ? value.system : null
   };
 }
@@ -137727,7 +138086,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 (!isPlainRecord8(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
@@ -146847,15 +147206,27 @@ function retainConstructionArguments(context, row, schemaClass2, expression, sou
   const constructorArgs2 = row.constructorArgs;
   if (!isObjectRecord(constructorArgs2)) return;
   if (row.instanceConstructorId === null) return;
-  const constructor2 = storedValueConstructor(
-    context,
-    schemaClass2,
-    recordedStoredConstructorId(row, schemaClass2)
+  const constructorId = recordedStoredConstructorId(row, schemaClass2);
+  const stored = context.state[`constructor:${constructorId}`]?.data;
+  if (!isObjectRecord(stored)) {
+    throw new Error(
+      `Stored construction for ${schemaClass2.name} names missing pulled constructor ${constructorId}.`
+    );
+  }
+  if (stored.classId !== schemaClass2.id) {
+    throw new Error(
+      `Stored constructor ${constructorId} does not belong to ${schemaClass2.name}.`
+    );
+  }
+  const argumentsValue = documentArgumentsToManifest(
+    stored.argumentTypes,
+    { recordKind: "constructor", recordId: constructorId, data: stored },
+    schemaClass2.source.span
   );
   const authoredArguments = constructorArgumentExpressions(expression);
   const argumentEnvironment = valueGenericEnvironment(row, environment);
-  for (let index = 0; index < constructor2.arguments.length; index += 1) {
-    const argument2 = constructor2.arguments[index];
+  for (let index = 0; index < argumentsValue.length; index += 1) {
+    const argument2 = argumentsValue[index];
     if (argument2 === void 0) continue;
     const valueId = constructorArgs2[`__arg_${index}__`];
     if (typeof valueId !== "string") continue;
@@ -147641,6 +148012,7 @@ function lowerRawMemberTypeName(context, memberId) {
   if (member.kind === 8 /* Enum */ && typeof member.enumId === "string") {
     return context.enumNames.get(member.enumId) ?? null;
   }
+  if (member.kind === 9 /* Lookup */) return "Reference";
   if (member.kind === 6 /* List */) return "List";
   if (member.kind === 28 /* Set */) return "Set";
   if (member.kind === 5 /* Dictionary */) return "Dictionary";
@@ -147655,6 +148027,8 @@ function lowerSchemaMemberTypeName(context, member) {
       return context.referenceTypes().interfaceImplementers().interface(member.interfaceId)?.name ?? null;
     case "enum":
       return context.enumNames.get(member.enumId) ?? null;
+    case "lookup":
+      return "Reference";
     case "list":
       return "List";
     case "set":
@@ -150655,10 +151029,15 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
       throw new Error(
         `Stored constructor argument cannot be typed by interface type parameter ${type.genericParamId} of ${type.ownerInterfaceId}.`
       );
-    case "generic":
+    case "generic": {
+      const binding = storedGenericArgumentType(context, type, environment);
+      const argumentType = binding.kind === "reference" ? withSchemaTypeNullability(
+        referenceReadType2(context, binding.target),
+        binding.nullable
+      ) : binding;
       return storedConstructorArgumentSource(
         context,
-        storedGenericArgumentType(context, type, environment),
+        argumentType,
         value,
         environment,
         visited,
@@ -150666,6 +151045,7 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         partial,
         constructorOwnsGraph
       );
+    }
     case "interface":
     case "list":
     case "set":
@@ -150701,6 +151081,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,
         {
@@ -150708,7 +151093,7 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
           name: "argument",
           kind: 9 /* Lookup */
         },
-        value,
+        [value],
         false,
         storedTypeArgumentName(context, type.target, environment)
       );
@@ -150857,8 +151242,14 @@ function schemaTypeForBindingMember(context, memberId, environment, visited = /*
       };
     case "lookup": {
       if (member.declaredType !== null) {
-        const target = referenceReadType2(context, member.declaredType);
-        return member.collectionMemberId === null && member.multiselect ? { kind: "lookup", nullable: nullable2, entryType: target } : withSchemaTypeNullability(target, nullable2);
+        if (member.collectionMemberId === null && member.multiselect) {
+          return {
+            kind: "lookup",
+            nullable: nullable2,
+            entryType: referenceReadType2(context, member.declaredType)
+          };
+        }
+        return { kind: "reference", nullable: nullable2, target: member.declaredType };
       }
       if (member.collectionMemberId === null) {
         throw new Error(
@@ -151427,7 +151818,8 @@ function resolveGenericValueMember(context, member, environment) {
   }
   return {
     ...bindingMember,
-    id: member.id,
+    // Lookup emission reads the binding's declared target and collection.
+    id: bindingMember.kind === 9 /* Lookup */ ? bindingMemberId : member.id,
     name: member.name,
     defaultValue: member.defaultValue,
     ...member.payload === 1 /* Partial */ ? { payload: 1 /* Partial */ } : {}
@@ -151505,7 +151897,8 @@ function resolveGenericSchemaMember(context, member, environment) {
   }
   const resolved = {
     ...bindingMember,
-    id: member.id,
+    // Deferred reference checks resolve this concrete lookup declaration.
+    id: bindingMember.kind === "lookup" ? bindingMemberId : member.id,
     name: member.name,
     defaultValue: member.defaultValue
   };
@@ -153164,8 +153557,15 @@ function reconcileMaterializedInitializersV4(args) {
     );
   }
   let currentRows;
-  let currentReader;
+  let compareConstruction;
   let ownedValues;
+  const storedOwnedValues = () => {
+    if (ownedValues !== void 0) return ownedValues;
+    const storedDocument = currentState().document;
+    compilePulledUncompiledConstructorsV4(storedDocument);
+    assertPulledConstructorsCompiled(storedDocument);
+    return ownedValues = createOwnedValueDeletionCollector(storedDocument);
+  };
   const rebuilds = [];
   for (const reconciliation of constructions.values()) {
     if (!replayableValueIds.has(reconciliation.valueId)) continue;
@@ -153217,8 +153617,14 @@ function reconcileMaterializedInitializersV4(args) {
       currentState().document,
       replayDocument
     );
-    currentReader ??= new EffectiveValueReader(
-      storedRowsDocument(replayDocument, currentRows)
+    compareConstruction ??= createConstructionReplayComparer(
+      new EffectiveValueReader(storedRowsDocument(replayDocument, currentRows)),
+      (root, member) => {
+        return storedOwnedValues().collect({
+          rootIds: [root.id],
+          rootMembers: /* @__PURE__ */ new Map([[root.id, member]])
+        });
+      }
     );
     const replay = replayRows.get(reconciliation.valueId);
     if (replay === void 0) {
@@ -153248,13 +153654,12 @@ function reconcileMaterializedInitializersV4(args) {
       );
       continue;
     }
-    if (reconciliation.kind === "storedArguments" && storedArgumentsMatch({
-      reader: currentReader,
-      stored: reconciliation.storedConstructorArgs,
+    if (reconciliation.kind === "storedArguments" && compareConstruction({
       currentRoot,
-      replay,
+      currentArguments: reconciliation.storedConstructorArgs,
+      replayRoot: replay,
       replayRows,
-      owner
+      rootMember: owner
     })) {
       continue;
     }
@@ -153266,11 +153671,10 @@ function reconcileMaterializedInitializersV4(args) {
         `Cannot rebuild construction for value "${reconciliation.valueId}": its pulled row is missing.`
       );
     }
-    ownedValues ??= createOwnedValueDeletionCollector(replayDocument);
     rebuilds.push({
       valueId: reconciliation.valueId,
       row: rebuiltConstructionRow(stored, reconciliation.code),
-      ownedValueIds: ownedValues.collect({
+      ownedValueIds: storedOwnedValues().collect({
         rootIds: [reconciliation.valueId],
         rootMembers: /* @__PURE__ */ new Map([[reconciliation.valueId, owner]])
       })
@@ -153313,22 +153717,6 @@ function sameCompiledProgram(left, right) {
     return literal3 && key === "value" ? isDeepStrictEqual(left[key], right[key]) : sameCompiledProgram(left[key], right[key]);
   });
 }
-function storedArgumentsMatch(args) {
-  const replayArgs = isLiteralValueContent(args.replay) ? args.replay.constructorArgs : void 0;
-  if (!isObjectRecord(replayArgs)) return false;
-  const [storedArgs, replayedArgs] = withoutSharedArguments(
-    args.stored,
-    replayArgs
-  );
-  return effectiveValuesEqual(
-    args.reader.normalizeConstructorArguments(
-      storedArgs,
-      args.currentRoot,
-      args.owner
-    ),
-    args.reader.withRowOverrides(args.replayRows).normalizeConstructorArguments(replayedArgs, args.replay, args.owner)
-  );
-}
 function rebuiltConstructionRow(data, code) {
   return { ...withoutMaterializedInstanceFields(data), init: { code } };
 }
@@ -153443,16 +153831,6 @@ function storedRowsWithRenamedKeys(before, after) {
   }
   return rows;
 }
-function withoutSharedArguments(stored, replayed) {
-  const storedRest = { ...stored };
-  const replayedRest = { ...replayed };
-  for (const [slot, value] of Object.entries(stored)) {
-    if (typeof value !== "string" || replayed[slot] !== value) continue;
-    delete storedRest[slot];
-    delete replayedRest[slot];
-  }
-  return [storedRest, replayedRest];
-}
 function pulledStateDocumentV4(workspace) {
   const state = workspace.state.records;
   const remembered = pulledStateDocuments.get(state);
@@ -153539,6 +153917,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()
   );
@@ -153735,6 +154114,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];
@@ -153917,7 +154297,7 @@ var init_local_initializer_materialization = __esm({
     init_stored_closure_captures();
     init_initializer_dependencies();
     init_initializer_replay();
-    init_effective_value_comparison();
+    init_construction_replay_equality();
     init_constructor_argument_ownership();
     init_neo_script_recompile_scope();
     init_compiler_adapter();
@@ -153931,6 +154311,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();
@@ -156980,7 +157361,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;
@@ -157002,16 +157383,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);
@@ -157021,7 +157395,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;
@@ -157042,16 +157416,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);
@@ -157059,83 +157426,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;
@@ -157145,13 +157516,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,
@@ -157165,7 +157530,6 @@ function resolveRootPathDialogueGroupCollectionValuesV4(args) {
           label: String(record7.fileFields.name)
         }
       }),
-      args.resolveVirtualPath,
       args.unavailableSlots
     );
     if (target !== null) record7.fileFields.collectionValueId = target;
@@ -157184,7 +157548,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) {
@@ -157211,7 +157575,7 @@ function walkRootValuePath(path, state, registry, placements, rootValues, fail2,
     return null;
   }
   return walkValueSegments(
-    { state, registry, placements, resolveVirtualPath, isComputed },
+    walk,
     slotValueId,
     segments.slice(2),
     path,
@@ -157221,7 +157585,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)) {
@@ -157232,12 +157596,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.`
       );
@@ -157249,7 +157622,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.`
         );
@@ -157277,6 +157650,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) => [
@@ -157341,6 +157774,7 @@ var init_root_source = __esm({
     init_project_root();
     init_value_comparison();
     init_members();
+    init_virtual_instance_graph();
     init_value_sources();
     init_source_format();
     init_stored_value_placements();
@@ -160640,7 +161074,8 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     state: rootPathResolutionState,
     resolveVirtualPath,
     unavailableSlots: rootValues.unavailableSlots,
-    registry: valueLowerRegistry
+    registry: valueLowerRegistry,
+    initBuiltSlots: "derive"
   });
   const resolvedDefaultKeys = resolveKeyReferenceMemberDefaultsV4({
     manifest,
@@ -160995,7 +161430,8 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
         state: rootPathResolutionState,
         resolveVirtualPath,
         unavailableSlots: rootValues.unavailableSlots,
-        registry: valueLowerRegistry
+        registry: valueLowerRegistry,
+        initBuiltSlots: "refuse"
       })
     }
   );
@@ -181762,7 +182198,7 @@ function collectUnityReferencedProjectFileIds(args) {
     )) {
       instanceEnv.set(paramId, { kind: "member", memberId: boundMemberId });
     }
-    const childValueIds = isStringRecord9(storedValue) ? storedValue : {};
+    const childValueIds = isStringRecord10(storedValue) ? storedValue : {};
     for (const entry of schema) {
       if (entry.memberId === null) continue;
       const childMember = substituteWalkMember(
@@ -181825,7 +182261,7 @@ function collectUnityReferencedProjectFileIds(args) {
     return;
   }
   if (isMemberDictionaryBase(member)) {
-    const childValueIds = isStringRecord9(storedValue) ? storedValue : {};
+    const childValueIds = isStringRecord10(storedValue) ? storedValue : {};
     const substitutedEntryMember = substituteWalkMember(
       member.entryMemberId,
       args.genericEnv,
@@ -181859,7 +182295,7 @@ function readGenericBindingsFromValue(value) {
   if (value == null) return {};
   if (!isLiteralValueContent(value)) return {};
   const bindings = Reflect.get(value, "genericBindings");
-  return isStringRecord9(bindings) ? bindings : {};
+  return isStringRecord10(bindings) ? bindings : {};
 }
 function readClassIdFromMemberValueBase(value) {
   if (value === null) return null;
@@ -181879,7 +182315,7 @@ function readFileIdFromMemberValue(value) {
   if (fileId.trim().length === 0) return null;
   return fileId;
 }
-function isStringRecord9(value) {
+function isStringRecord10(value) {
   if (value === null) return false;
   if (typeof value !== "object") return false;
   return Object.values(value).every((entry) => typeof entry === "string");
@@ -186416,17 +186852,36 @@ function generateInheritedPropertyInterfaceAdapters(ctx, classDef, genericEnv) {
         continue;
       }
       const source = `((${receiverType})this).${memberName}`;
-      const getter = isMemberWithEntries(member) && interfaceValueType.startsWith("NeoReadOnly") ? readExpression(
+      const memberSaved = memberSavedForStorage(
         ctx,
-        member,
-        schemaKey,
-        neoMemberNodeType(member),
+        memberId,
         false,
-        receiverType,
-        null,
-        genericEnv,
         declarationClass.id
-      ) : [`return (${interfaceValueType})(object)${source}!;`];
+      );
+      const getter = isMemberWithEntries(member) ? [
+        ...detachedReadExpression(
+          ctx,
+          member,
+          schemaKey,
+          memberSaved,
+          null,
+          genericEnv,
+          declarationClass.id,
+          false
+        ),
+        ...collectionReadExpression(
+          ctx,
+          member,
+          `node.Get<${neoMemberNodeType(member)}>("${escapeCSharpString(schemaKey)}")`,
+          schemaKey,
+          resolveMemberById(ctx, member.entryMemberId, "entryMemberId"),
+          memberSaved,
+          null,
+          genericEnv,
+          interfaceValueType,
+          false
+        )
+      ] : [`return (${interfaceValueType})(object)${source}!;`];
       const hasSetter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string";
       const adapter = [
         `${interfaceValueType} ${interfaceType2}.${memberName}`,
@@ -190369,7 +190824,7 @@ function readExpression(ctx, member, schemaKey, nodeType, saved, ownerClassName,
     )
   ];
 }
-function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberName, genericEnv, ownerClassId) {
+function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberName, genericEnv, ownerClassId, genericBindingSaved = saved) {
   if (ownerClassId === void 0 || !classSupportsDetachedViews(ctx, ownerClassId)) {
     return [];
   }
@@ -190399,7 +190854,13 @@ function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberN
       saved,
       genericEnv
     );
-    const entryType = csharpValueType(ctx, entryMember, saved, genericEnv);
+    const entryType = csharpValueType(
+      ctx,
+      entryMember,
+      saved,
+      genericEnv,
+      genericBindingSaved
+    );
     if (readEntry2 === null || entryType === null) return [];
     const guardArguments = collectionGuardArguments(
       member,
@@ -190407,10 +190868,10 @@ function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberN
     );
     const [viewType, view] = saved ? [
       `NeoList<${entryType}>`,
-      `DetachedList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, true, writeGuardMemberName != null, genericEnv)}, item => ${entrySerializeExpression(ctx, entryMember, `writableNode.Get<NeoMemberListWritable>("${key}")`, member.name, genericEnv)}${guardArguments})`
+      `DetachedList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, true, writeGuardMemberName != null, genericEnv, genericBindingSaved)}, item => ${entrySerializeExpression(ctx, entryMember, `writableNode.Get<NeoMemberListWritable>("${key}")`, member.name, genericEnv, genericBindingSaved)}${guardArguments})`
     ] : [
       `NeoReadOnlyList<${entryType}>`,
-      `DetachedReadOnlyList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, false, false, genericEnv)})`
+      `DetachedReadOnlyList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, false, false, genericEnv, genericBindingSaved)})`
     ];
     return [
       `if (TryReadDetached("${key}", out _))`,
@@ -190947,12 +191408,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(
@@ -190964,13 +191425,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);
@@ -191092,9 +191554,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;
@@ -191210,7 +191672,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?>";
@@ -191232,7 +191694,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)`;
   }
@@ -191281,7 +191749,13 @@ function childConverter(ctx, member, saved = false, branchOnReadOnly = false, ge
   }
   if (isClassTypedMember(member)) {
     const typeName = ctx.typeNames.get(member.classId) ?? "NeoNode";
-    const constructedSuffix = constructedTypeArgumentsSuffix(ctx, member, true, genericEnv) ?? "";
+    const constructedSuffix = constructedTypeArgumentsSuffix(
+      ctx,
+      member,
+      true,
+      genericEnv,
+      genericBindingSaved
+    ) ?? "";
     const savedTypeRef = `${qualifyGeneratedType(ctx, savedTypeName(typeName))}${constructedSuffix}`;
     const hasWritableFamily = schemaClassHasWritableFamily(ctx, member.classId);
     if (saved && branchOnReadOnly && hasWritableFamily) {
@@ -194863,7 +195337,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 = "f748ddae5544d547b4d1139dcdbc86b86b01ab0aae4a9a24656ad8858258b460";
   }
 });
 
@@ -216001,7 +216475,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.84.2");
+    console.log("0.84.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {