@neocompose/cli 0.38.1 → 0.38.2

package/dist/neo.mjs

@@ -11838,7 +11838,7 @@ var init_strict_resolver = __esm({
                 expression.pos
               );
             }
-            if (expression.initializer && expression.initializer.length > 0 && !projectionCall) {
+            if (expression.initializer && expression.initializer.length > 0 && !projectionCall && this.context.storedConstructionReplay !== true) {
               throw new CompileError(
                 "Object initializers are available to project source construction and are not executable NeoScript constructors.",
                 expression.pos
@@ -61807,9 +61807,504 @@ var init_lower_variants = __esm({
   }
 });
 
+// ../src/models/constructors/constructors.ts
+function hasRejectedConstructorKey(value) {
+  return REJECTED_CONSTRUCTOR_KEYS.some((key) => value[key] !== void 0);
+}
+function isNamedBaseClauseEntry(value, nameIsValid) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const candidate = value;
+  if (!Object.keys(candidate).every((key) => key === "name" || key === "code")) {
+    return false;
+  }
+  if (!nameIsValid(candidate.name)) return false;
+  if (typeof candidate.code !== "string") return false;
+  return candidate.code.length > 0;
+}
+function isNeoConstructorBaseArgument(value) {
+  return isNamedBaseClauseEntry(value, isValidCallableArgumentIdentifier);
+}
+function isNeoConstructorBaseInitializerField(value) {
+  return isNamedBaseClauseEntry(value, isValidSchemaMemberIdentifier);
+}
+function isNeoClassConstructorBase(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const v = value;
+  if (hasRejectedConstructorKey(v)) return false;
+  if (!isValidDocsText(v.docsText)) return false;
+  if (typeof v.classId !== "string") return false;
+  if (v.classId.length === 0) return false;
+  if (typeof v.code !== "string" && v.code !== null) return false;
+  if (!Array.isArray(v.argumentTypes)) return false;
+  const parameterNames = /* @__PURE__ */ new Set();
+  const argumentTypes = [];
+  for (const argument2 of v.argumentTypes) {
+    if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
+    if (!isValidCallableArgumentIdentifier(argument2.name)) return false;
+    if (parameterNames.has(argument2.name)) return false;
+    parameterNames.add(argument2.name);
+    argumentTypes.push(argument2);
+  }
+  if (validateParameterDefaults(argumentTypes).length > 0) return false;
+  if (v.baseArguments !== void 0 && v.baseArguments !== null) {
+    if (!Array.isArray(v.baseArguments)) return false;
+    const baseNames = /* @__PURE__ */ new Set();
+    for (const baseArgument of v.baseArguments) {
+      if (!isNeoConstructorBaseArgument(baseArgument)) return false;
+      if (baseNames.has(baseArgument.name)) return false;
+      baseNames.add(baseArgument.name);
+    }
+  }
+  if (v.baseInitializerFields !== void 0 && v.baseInitializerFields !== null) {
+    if (!Array.isArray(v.baseInitializerFields)) return false;
+    const fieldNames = /* @__PURE__ */ new Set();
+    for (const field of v.baseInitializerFields) {
+      if (!isNeoConstructorBaseInitializerField(field)) return false;
+      if (fieldNames.has(field.name)) return false;
+      fieldNames.add(field.name);
+    }
+  }
+  if (v.action !== void 0 && v.action !== null) return false;
+  if (v.compiledBaseArguments !== void 0 && v.compiledBaseArguments !== null) {
+    return false;
+  }
+  return v.compiledBaseInitializerFields === void 0 || v.compiledBaseInitializerFields === null;
+}
+function isUncompiledNeoClassConstructor(value) {
+  if (!isNeoClassConstructorBase(value)) return false;
+  const v = value;
+  if (typeof v.id !== "string" || v.id.length === 0) return false;
+  if (typeof v.projectId !== "string" || v.projectId.length === 0) return false;
+  if (!isEpochMillis(v.createdAt)) return false;
+  return isEpochMillis(v.updatedAt);
+}
+function hasValidConstructorAction(action, argumentTypes) {
+  if (!isNSFunctionWithReturnType(action)) return false;
+  if (action.typeInfo.type !== 0 /* Null */) return false;
+  if (action.typeInfo.required !== true) return false;
+  if (action.parameters.length !== argumentTypes.length + 2) return false;
+  if (action.parameters[0]?.id !== "__this__") return false;
+  if (action.parameters[1]?.id !== "__root__") return false;
+  for (let index = 0; index < argumentTypes.length; index += 1) {
+    const parameter4 = action.parameters[index + 2];
+    if (parameter4?.id !== `__arg_${index}__`) return false;
+    const declared = argumentTypes[index];
+    if (declared === void 0) return false;
+    if (!typeInfosInvariantlyEqual(parameter4.typeInfo, declared)) return false;
+  }
+  return true;
+}
+function compiledBaseClauseGettersAlign(compiled, authored) {
+  const authoredCount = Array.isArray(authored) ? authored.length : 0;
+  if (compiled === void 0 || compiled === null) return authoredCount === 0;
+  if (!Array.isArray(compiled)) return false;
+  if (!compiled.every(isNSGetter)) return false;
+  return compiled.length === authoredCount;
+}
+function isNeoClassConstructorProps(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  const {
+    action: _action,
+    compiledBaseArguments: _compiledBaseArguments,
+    compiledBaseInitializerFields: _compiledBaseInitializerFields,
+    ...authored
+  } = v;
+  void _action;
+  void _compiledBaseArguments;
+  void _compiledBaseInitializerFields;
+  if (!isNeoClassConstructorBase(authored)) return false;
+  if (typeof v.id !== "string") return false;
+  if (v.id.length === 0) return false;
+  if (typeof v.projectId !== "string") return false;
+  if (!isEpochMillis(v.createdAt)) return false;
+  if (!isEpochMillis(v.updatedAt)) return false;
+  const argumentTypes = v.argumentTypes;
+  if (!hasValidConstructorAction(v.action, argumentTypes)) return false;
+  if (!compiledBaseClauseGettersAlign(v.compiledBaseArguments, v.baseArguments)) {
+    return false;
+  }
+  return compiledBaseClauseGettersAlign(
+    v.compiledBaseInitializerFields,
+    v.baseInitializerFields
+  );
+}
+function isNeoClassConstructor(value) {
+  return isNeoClassConstructorProps(value);
+}
+function constructorActionParameterId(constructor2, index) {
+  const action = "action" in constructor2 ? constructor2.action : void 0;
+  if (action !== null && typeof action === "object") {
+    const parameters = action.parameters;
+    if (Array.isArray(parameters)) {
+      const parameter4 = parameters[index + 2];
+      if (parameter4 !== null && typeof parameter4 === "object" && typeof parameter4.id === "string") {
+        return parameter4.id;
+      }
+    }
+  }
+  return `__arg_${index}__`;
+}
+var REJECTED_CONSTRUCTOR_KEYS;
+var init_constructors = __esm({
+  "../src/models/constructors/constructors.ts"() {
+    "use strict";
+    init_core();
+    init_docs_text2();
+    init_member_kinds();
+    init_schema_identifiers();
+    init_neoscript();
+    REJECTED_CONSTRUCTOR_KEYS = [
+      "bodyMode",
+      "uiAction",
+      "returnTypeInfo",
+      "deferred"
+    ];
+  }
+});
+
+// ../src/models/constructors/index.ts
+var init_constructors2 = __esm({
+  "../src/models/constructors/index.ts"() {
+    "use strict";
+    init_constructors();
+  }
+});
+
+// ../src/models/classes/constructor-parameter-settlement.ts
+function createConstructorSettlementResolver(view) {
+  const classesById2 = new Map(
+    view.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const membersById2 = new Map(
+    view.members.map((member) => [member.id, member])
+  );
+  const constructorsById = new Map(
+    (view.constructors ?? []).map((constructor2) => [
+      constructor2.id,
+      constructor2
+    ])
+  );
+  const directResultByClassAndParameter = /* @__PURE__ */ new Map();
+  const recordedResultByConstructorAndParameter = /* @__PURE__ */ new Map();
+  const directSettlement = (classId, parameterName) => {
+    const cacheKey = `${classId}\0${parameterName}`;
+    if (directResultByClassAndParameter.has(cacheKey)) {
+      return directResultByClassAndParameter.get(cacheKey) ?? null;
+    }
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = classId;
+    while (currentId !== null && !visited.has(currentId)) {
+      visited.add(currentId);
+      const schemaClass2 = classesById2.get(currentId);
+      if (schemaClass2 === void 0) break;
+      for (const [schemaKey, memberId] of Object.entries(
+        schemaClass2.schema ?? {}
+      )) {
+        if (typeof memberId !== "string") continue;
+        const member = membersById2.get(memberId);
+        const defaultRecord = asRecord(member?.defaultValue);
+        const initRecord = asRecord(defaultRecord?.init);
+        if (initRecord !== null && typeof initRecord.code === "string" && initRecord.code.trim() === parameterName) {
+          const result = { schemaKey, memberId };
+          directResultByClassAndParameter.set(cacheKey, result);
+          return result;
+        }
+      }
+      currentId = schemaClass2.extendsClassId ?? null;
+    }
+    directResultByClassAndParameter.set(cacheKey, null);
+    return null;
+  };
+  const memberIdForSchemaKey = (classId, schemaKey) => {
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = classId;
+    while (currentId !== null && !visited.has(currentId)) {
+      visited.add(currentId);
+      const schemaClass2 = classesById2.get(currentId);
+      if (schemaClass2 === void 0) return null;
+      const memberId = schemaClass2.schema?.[schemaKey];
+      if (typeof memberId === "string") return memberId;
+      currentId = schemaClass2.extendsClassId ?? null;
+    }
+    return null;
+  };
+  const recordedSettlement = (classId, parameterName, constructorId, resolving) => {
+    const cacheKey = `${classId}\0${constructorId}\0${parameterName}`;
+    if (recordedResultByConstructorAndParameter.has(cacheKey)) {
+      return recordedResultByConstructorAndParameter.get(cacheKey) ?? null;
+    }
+    if (resolving.has(cacheKey)) return null;
+    const constructor2 = constructorsById.get(constructorId);
+    if (constructor2?.classId !== classId) {
+      recordedResultByConstructorAndParameter.set(cacheKey, null);
+      return null;
+    }
+    const direct = directSettlement(classId, parameterName);
+    if (direct !== null) {
+      recordedResultByConstructorAndParameter.set(cacheKey, direct);
+      return direct;
+    }
+    const schemaClass2 = classesById2.get(classId);
+    const baseClassId = schemaClass2?.extendsClassId;
+    if (typeof baseClassId !== "string") {
+      recordedResultByConstructorAndParameter.set(cacheKey, null);
+      return null;
+    }
+    for (const field of constructor2.baseInitializerFields ?? []) {
+      const record3 = asRecord(field);
+      if (typeof record3?.name !== "string" || typeof record3.code !== "string" || record3.code.trim() !== parameterName) {
+        continue;
+      }
+      const memberId = memberIdForSchemaKey(baseClassId, record3.name);
+      if (memberId !== null) {
+        const result = { schemaKey: record3.name, memberId };
+        recordedResultByConstructorAndParameter.set(cacheKey, result);
+        return result;
+      }
+    }
+    const baseConstructorId = classesById2.get(baseClassId)?.requiredConstructorId;
+    if (typeof baseConstructorId !== "string") {
+      recordedResultByConstructorAndParameter.set(cacheKey, null);
+      return null;
+    }
+    resolving.add(cacheKey);
+    for (const argument2 of constructor2.baseArguments ?? []) {
+      const record3 = asRecord(argument2);
+      if (typeof record3?.name !== "string" || typeof record3.code !== "string" || record3.code.trim() !== parameterName) {
+        continue;
+      }
+      const result = recordedSettlement(
+        baseClassId,
+        record3.name,
+        baseConstructorId,
+        resolving
+      );
+      resolving.delete(cacheKey);
+      recordedResultByConstructorAndParameter.set(cacheKey, result);
+      return result;
+    }
+    resolving.delete(cacheKey);
+    recordedResultByConstructorAndParameter.set(cacheKey, null);
+    return null;
+  };
+  return (classId, parameterName, constructorId) => constructorId === void 0 ? directSettlement(classId, parameterName) : recordedSettlement(classId, parameterName, constructorId, /* @__PURE__ */ new Set());
+}
+function constructorSettledSchemaEntry(view, classId, parameterName, constructorId) {
+  return createConstructorSettlementResolver(view)(
+    classId,
+    parameterName,
+    constructorId
+  );
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+var init_constructor_parameter_settlement = __esm({
+  "../src/models/classes/constructor-parameter-settlement.ts"() {
+    "use strict";
+  }
+});
+
+// src/project-source/stored-value-placements.ts
+function buildStoredValuePlacementIndexV4(records2) {
+  const live = [...records2].filter((record3) => record3.deleted !== true);
+  const values = /* @__PURE__ */ new Map();
+  const classes = [];
+  const members = [];
+  const memberDataById = /* @__PURE__ */ new Map();
+  const constructors = /* @__PURE__ */ new Map();
+  const variantTargetClassByRootValueId = /* @__PURE__ */ new Map();
+  for (const record3 of live) {
+    if (!isObjectRecord2(record3.data)) continue;
+    if (record3.recordKind === "value") {
+      values.set(record3.recordId, record3.data);
+    } else if (record3.recordKind === "class") {
+      classes.push({
+        id: record3.recordId,
+        ...isStringRecord2(record3.data.schema) ? { schema: record3.data.schema } : {},
+        ...typeof record3.data.extendsClassId === "string" || record3.data.extendsClassId === null ? { extendsClassId: record3.data.extendsClassId } : {},
+        ...typeof record3.data.requiredConstructorId === "string" ? { requiredConstructorId: record3.data.requiredConstructorId } : {},
+        ...Array.isArray(record3.data.genericParams) ? {
+          genericParamIds: record3.data.genericParams.flatMap(
+            (entry) => isObjectRecord2(entry) && typeof entry.id === "string" ? [entry.id] : []
+          )
+        } : {}
+      });
+    } else if (record3.recordKind === "member") {
+      memberDataById.set(record3.recordId, record3.data);
+      members.push({
+        id: record3.recordId,
+        ...record3.data.defaultValue === void 0 ? {} : { defaultValue: record3.data.defaultValue }
+      });
+    } else if (record3.recordKind === "constructor") {
+      constructors.set(record3.recordId, record3.data);
+    } else if (record3.recordKind === "variant" && typeof record3.data.valueId === "string" && typeof record3.data.classId === "string") {
+      variantTargetClassByRootValueId.set(
+        record3.data.valueId,
+        record3.data.classId
+      );
+    }
+  }
+  const classesById2 = new Map(
+    classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const resolveSettlement = createConstructorSettlementResolver({
+    classes,
+    constructors: [...constructors].flatMap(
+      ([id2, constructor2]) => typeof constructor2.classId === "string" ? [
+        {
+          id: id2,
+          classId: constructor2.classId,
+          ...Array.isArray(constructor2.baseArguments) ? { baseArguments: constructor2.baseArguments } : {},
+          ...Array.isArray(constructor2.baseInitializerFields) ? {
+            baseInitializerFields: constructor2.baseInitializerFields
+          } : {}
+        }
+      ] : []
+    ),
+    members
+  });
+  const memberIdForSchemaKey = (classId, schemaKey) => {
+    const visited = /* @__PURE__ */ new Set();
+    let cursor = classId;
+    while (cursor !== null && !visited.has(cursor)) {
+      visited.add(cursor);
+      const schemaClass2 = classesById2.get(cursor);
+      if (schemaClass2 === void 0) return null;
+      const memberId = schemaClass2.schema?.[schemaKey];
+      if (typeof memberId === "string") return memberId;
+      cursor = schemaClass2.extendsClassId ?? null;
+    }
+    return null;
+  };
+  const childrenByParentValueId = /* @__PURE__ */ new Map();
+  const placementByChildValueId = /* @__PURE__ */ new Map();
+  const add = (edge) => {
+    const children = childrenByParentValueId.get(edge.parentValueId) ?? /* @__PURE__ */ new Map();
+    if (children.has(edge.schemaKey)) return;
+    children.set(edge.schemaKey, edge);
+    childrenByParentValueId.set(edge.parentValueId, children);
+    if (!placementByChildValueId.has(edge.childValueId)) {
+      placementByChildValueId.set(edge.childValueId, edge);
+    }
+  };
+  for (const [parentValueId, value] of values) {
+    const classId = typeof value.classId === "string" ? value.classId : null;
+    const body = value.value;
+    if (isObjectRecord2(body)) {
+      for (const [schemaKey, childValueId] of Object.entries(body)) {
+        if (typeof childValueId !== "string" || !values.has(childValueId)) {
+          continue;
+        }
+        add({
+          childValueId,
+          memberId: classId === null ? null : memberIdForSchemaKey(classId, schemaKey),
+          parentValueId,
+          schemaKey,
+          source: "body"
+        });
+      }
+    }
+    const constructorId = value.instanceConstructorId;
+    const constructorArgs = value.constructorArgs;
+    if (classId === null || typeof constructorId !== "string" || !isObjectRecord2(constructorArgs)) {
+      continue;
+    }
+    const constructor2 = constructors.get(constructorId);
+    const parameters = constructor2?.argumentTypes;
+    if (constructor2 === void 0 || constructor2.classId !== classId || !Array.isArray(parameters)) {
+      continue;
+    }
+    for (const [index, parameter4] of parameters.entries()) {
+      if (!isObjectRecord2(parameter4) || typeof parameter4.name !== "string") {
+        continue;
+      }
+      const settled = resolveSettlement(classId, parameter4.name, constructorId);
+      if (settled === null) continue;
+      if (isObjectRecord2(body) && Object.hasOwn(body, settled.schemaKey)) {
+        continue;
+      }
+      const parameterId = constructorActionParameterId(constructor2, index);
+      const childValueId = constructorArgs[parameterId];
+      if (typeof childValueId !== "string" || !values.has(childValueId) || !memberStoresAggregate(
+        memberDataById.get(settled.memberId),
+        value,
+        memberDataById,
+        parentValueId,
+        classesById2,
+        variantTargetClassByRootValueId
+      )) {
+        continue;
+      }
+      add({
+        childValueId,
+        memberId: settled.memberId,
+        parentValueId,
+        schemaKey: settled.schemaKey,
+        source: "constructor"
+      });
+    }
+  }
+  return { childrenByParentValueId, placementByChildValueId };
+}
+function memberStoresAggregate(member, parent, membersById2, parentValueId, classesById2, variantTargetClassByRootValueId, visitedMemberIds = /* @__PURE__ */ new Set()) {
+  const kind = member?.kind;
+  if (kind === 5 /* Dictionary */ || kind === 6 /* List */ || kind === 7 /* Class */ || kind === "dictionary" || kind === "list" || kind === "class") {
+    return true;
+  }
+  if (kind !== 21 /* Generic */ && kind !== "generic") return false;
+  const memberId = typeof member?.id === "string" ? member.id : null;
+  if (memberId !== null && visitedMemberIds.has(memberId)) return false;
+  const genericParamId = member?.genericParamId;
+  const bindings = parent.genericBindings;
+  if (typeof genericParamId === "string" && isObjectRecord2(bindings)) {
+    const bindingMemberId = bindings[genericParamId];
+    if (typeof bindingMemberId === "string") {
+      return memberStoresAggregate(
+        membersById2.get(bindingMemberId),
+        parent,
+        membersById2,
+        parentValueId,
+        classesById2,
+        variantTargetClassByRootValueId,
+        /* @__PURE__ */ new Set([
+          ...visitedMemberIds,
+          ...memberId === null ? [] : [memberId]
+        ])
+      );
+    }
+  }
+  const parentClassId = parent.classId;
+  const variantTargetClassId = variantTargetClassByRootValueId.get(parentValueId);
+  if (typeof parentClassId === "string" && typeof variantTargetClassId === "string" && classesById2.get(parentClassId)?.genericParamIds?.[0] === genericParamId && classesById2.has(variantTargetClassId)) {
+    return true;
+  }
+  return false;
+}
+function isStringRecord2(value) {
+  return isObjectRecord2(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+var init_stored_value_placements = __esm({
+  "src/project-source/stored-value-placements.ts"() {
+    "use strict";
+    init_constructors2();
+    init_constructor_parameter_settlement();
+    init_members();
+    init_projection();
+  }
+});
+
 // src/project-source/root-value-paths.ts
-function rootValuePathsByValueId(records2) {
-  const indexed = indexRecords(records2);
+function rootValuePathsByValueId(records2, storedPlacements) {
+  const allRecords = [...records2];
+  const indexed = indexRecords(allRecords);
+  const placements = storedPlacements ?? buildStoredValuePlacementIndexV4(allRecords);
   const paths = /* @__PURE__ */ new Map();
   const queue = [];
   for (const [field, slot] of ROOT_PROJECT_FIELDS) {
@@ -61825,19 +62320,18 @@ function rootValuePathsByValueId(records2) {
     if (next === void 0) break;
     if (paths.has(next.id)) continue;
     paths.set(next.id, next.path);
-    const body = indexed.values.get(next.id)?.value;
-    if (!isObjectRecord3(body)) continue;
-    for (const [schemaKey, child] of Object.entries(body)) {
-      if (typeof child !== "string") continue;
-      if (!indexed.values.has(child)) continue;
-      queue.push({ id: child, path: `${next.path}.${schemaKey}` });
+    for (const edge of placements.childrenByParentValueId.get(next.id)?.values() ?? []) {
+      queue.push({
+        id: edge.childValueId,
+        path: `${next.path}.${edge.schemaKey}`
+      });
     }
   }
   return paths;
 }
-function rootValueTargetsByPath(records2) {
+function rootValueTargetsByPath(records2, storedPlacements) {
   const allRecords = [...records2];
-  const paths = rootValuePathsByValueId(allRecords);
+  const paths = rootValuePathsByValueId(allRecords, storedPlacements);
   const values = new Map(
     allRecords.flatMap(
       (record3) => !record3.deleted && record3.recordKind === "value" && isObjectRecord3(record3.data) ? [[record3.recordId, record3.data]] : []
@@ -61855,17 +62349,14 @@ function rootValueTargetsByPath(records2) {
 function indexRecords(records2) {
   let project;
   const members = /* @__PURE__ */ new Map();
-  const values = /* @__PURE__ */ new Map();
   for (const record3 of records2) {
     if (record3.deleted || !isObjectRecord3(record3.data)) continue;
     if (record3.recordKind === "project") project ??= record3.data;
     else if (record3.recordKind === "member") {
       members.set(record3.recordId, record3.data);
-    } else if (record3.recordKind === "value") {
-      values.set(record3.recordId, record3.data);
     }
   }
-  return { project, members, values };
+  return { project, members };
 }
 function isObjectRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -61874,6 +62365,7 @@ var ROOT_PROJECT_FIELDS;
 var init_root_value_paths = __esm({
   "src/project-source/root-value-paths.ts"() {
     "use strict";
+    init_stored_value_placements();
     ROOT_PROJECT_FIELDS = [
       ["rootAssetsMemberId", "Assets"],
       ["rootSaveFileMemberId", "Save"],
@@ -63504,7 +63996,12 @@ function compileNSInitializer(code, ctx) {
       `return
 ${code};`,
       createContext(
-        { ...compilerContext, thisClass: lexicalThisClass ?? null },
+        {
+          ...compilerContext,
+          thisClass: lexicalThisClass ?? null,
+          implicitMemberAccess: lexicalThisClass !== null,
+          staticMember: false
+        },
         {
           scriptKind: "initializer",
           returnTypeInfo: ctx.returnTypeInfo,
@@ -63760,9 +64257,6 @@ function initializerReferencedIdentifiers(source) {
   }
   return identifiers;
 }
-function initializerReferencesLexicalThis(source) {
-  return initializerReferencedIdentifiers(source).has("this");
-}
 function initializerReferencesAnyIdentifier(source, names) {
   const identifiers = initializerReferencedIdentifiers(source);
   for (const name of names) {
@@ -64636,7 +65130,7 @@ function isRecordValue(value) {
   if (Array.isArray(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
-function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots, rootOwners, rootKinds) {
+function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots, rootOwners, rootKinds, traversalExtension) {
   const resolved = /* @__PURE__ */ new Map();
   if (targetValueIds.size === 0) return resolved;
   const valuesById = new Map(document.values.map((value) => [value.id, value]));
@@ -64659,6 +65153,7 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
     }
   }
   const visited = /* @__PURE__ */ new Set();
+  const discoveredRoots = [];
   const declaringClassIdByMemberId = /* @__PURE__ */ new Map();
   for (const schemaClass2 of document.classes) {
     for (const memberId of Object.values(schemaClass2.schema)) {
@@ -64701,6 +65196,14 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
     visited.add(valueId);
     const value = valuesById.get(valueId);
     if (value === void 0) return;
+    discoveredRoots.push(
+      ...traversalExtension?.({
+        member,
+        valueId,
+        rootOwner,
+        rootKind
+      }) ?? []
+    );
     searchChildren(
       member,
       rootOwner,
@@ -64781,18 +65284,23 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
       return;
     }
   }
-  function searchRootMember(member, valueId, rootKind) {
+  function searchRootMember(member, valueId, rootKind, rootOwner = member) {
     const env = declaringClassEnv(member);
     searchRow(
       trySubstituteMember(member, env) ?? member,
       valueId,
-      member,
+      rootOwner,
       env,
       rootKind
     );
   }
   for (const root of additionalRoots ?? []) {
-    searchRootMember(root.member, root.valueId, "instance");
+    searchRootMember(
+      root.member,
+      root.valueId,
+      root.rootKind ?? "instance",
+      root.rootOwner
+    );
   }
   for (const member of document.members) {
     if (typeof member.valueId !== "string") continue;
@@ -64817,6 +65325,16 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
       "declaration"
     );
   }
+  for (let cursor = 0; cursor < discoveredRoots.length; cursor += 1) {
+    const root = discoveredRoots[cursor];
+    if (root === void 0) continue;
+    searchRootMember(
+      root.member,
+      root.valueId,
+      root.rootKind ?? "instance",
+      root.rootOwner
+    );
+  }
   return resolved;
 }
 var init_value_row_owner_members = __esm({
@@ -64830,21 +65348,91 @@ var init_value_row_owner_members = __esm({
 });
 
 // ../src/database/constructor-argument-ownership.ts
-function constructorActionParameterId(constructor2, index) {
-  const action = constructor2.action;
-  if (action !== null && typeof action === "object") {
-    const parameters = action.parameters;
-    if (Array.isArray(parameters)) {
-      const parameter4 = parameters[index + 2];
-      if (parameter4 !== null && typeof parameter4 === "object" && typeof parameter4.id === "string") {
-        return parameter4.id;
+function resolveSemanticOwnerMembersForValues(document, targetValueIds, additionalRoots, rootOwners, rootKinds) {
+  const result = /* @__PURE__ */ new Map();
+  if (targetValueIds.size === 0) return result;
+  const directRootOwners = /* @__PURE__ */ new Map();
+  const directRootKinds = /* @__PURE__ */ new Map();
+  const directOwners = resolveOwnerMembersForValues(
+    document,
+    targetValueIds,
+    additionalRoots,
+    directRootOwners,
+    directRootKinds
+  );
+  if (targetValueIds.size === directOwners.size) {
+    for (const valueId of targetValueIds) {
+      const owner = directOwners.get(valueId);
+      if (owner === void 0) continue;
+      result.set(valueId, owner);
+      const rootOwner = directRootOwners.get(valueId);
+      if (rootOwner !== void 0) rootOwners?.set(valueId, rootOwner);
+      const rootKind = directRootKinds.get(valueId);
+      if (rootKind !== void 0) rootKinds?.set(valueId, rootKind);
+    }
+    return result;
+  }
+  const graph = new MaterializedValueGraphContext(document);
+  const allValueIds = new Set(graph.valuesById.keys());
+  const semanticRoots = [
+    ...additionalRoots ?? []
+  ];
+  const semanticRootIds = new Set(semanticRoots.map((root) => root.valueId));
+  const bodyRootOwners = /* @__PURE__ */ new Map();
+  const bodyRootKinds = /* @__PURE__ */ new Map();
+  const bodyOwners = resolveOwnerMembersForValues(
+    document,
+    allValueIds,
+    additionalRoots,
+    bodyRootOwners,
+    bodyRootKinds
+  );
+  const allRootOwners = new Map(bodyRootOwners);
+  const allRootKinds = new Map(bodyRootKinds);
+  const owners = resolveOwnerMembersForValues(
+    document,
+    allValueIds,
+    semanticRoots,
+    allRootOwners,
+    allRootKinds,
+    ({ valueId: ownerValueId, rootOwner, rootKind }) => {
+      const roots = [];
+      for (const edge of graph.edgesByOwnerValueId.get(ownerValueId) ?? []) {
+        if (graph.referenceCountByTargetValueId.get(edge.targetValueId) !== 1) {
+          continue;
+        }
+        if (bodyOwners.has(edge.targetValueId)) continue;
+        if (semanticRootIds.has(edge.targetValueId)) continue;
+        const member = graph.constructorArgumentOwnerMember(edge);
+        if (member === void 0) continue;
+        semanticRootIds.add(edge.targetValueId);
+        roots.push({
+          member,
+          valueId: edge.targetValueId,
+          rootOwner,
+          rootKind
+        });
       }
+      return roots;
     }
+  );
+  for (const [valueId, owner] of bodyOwners) owners.set(valueId, owner);
+  for (const [valueId, owner] of bodyRootOwners) {
+    allRootOwners.set(valueId, owner);
   }
-  return `__arg_${index}__`;
-}
-function constructorArgumentAggregateEdgesForValue(document, row) {
-  return [...new MaterializedValueGraphContext(document).constructorEdges(row)];
+  for (const [valueId, kind] of bodyRootKinds) {
+    allRootKinds.set(valueId, kind);
+  }
+  for (const valueId of targetValueIds) {
+    const owner = owners.get(valueId);
+    if (owner === void 0) continue;
+    result.set(valueId, owner);
+    const rootOwner = allRootOwners.get(valueId);
+    if (rootOwner !== void 0) rootOwners?.set(valueId, rootOwner);
+    const rootKind = allRootKinds.get(valueId);
+    if (rootKind !== void 0) rootKinds?.set(valueId, rootKind);
+  }
+  return result;
 }
 function createTypedValueNormalizer(rows, document, childrenByContainerId, parameterTypesForRow, memberById2, memberTypeInfo) {
   const visiting = /* @__PURE__ */ new Set();
@@ -64858,6 +65446,16 @@ function createTypedValueNormalizer(rows, document, childrenByContainerId, param
       ])
     );
   };
+  const normalizeTypedLiteral = (value, typeInfo) => {
+    if (typeInfo.type === 25 /* NSDelegate */ && value !== null && typeof value === "object" && !Array.isArray(value) && typeof Reflect.get(value, "code") === "string") {
+      const captures = Reflect.get(value, "captures");
+      return {
+        code: Reflect.get(value, "code"),
+        ...captures === void 0 ? {} : { captures: normalizeLiteral(captures) }
+      };
+    }
+    return normalizeLiteral(value);
+  };
   const normalizeTypedRow = (valueId, typeInfo) => {
     const row = rows.get(valueId);
     if (row === void 0) return valueId;
@@ -64875,7 +65473,7 @@ function createTypedValueNormalizer(rows, document, childrenByContainerId, param
       ) : Array.isArray(row.value) ? row.value.map(
         (childId) => typeof childId === "string" ? normalizeTypedRow(childId, typeInfo.entryTypeInfo) : normalizeLiteral(childId)
       ) : normalizeLiteral(row.value);
-    } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord2(row.value)) {
+    } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord3(row.value)) {
       value = Object.fromEntries(
         Object.entries(row.value).map(([key, childId]) => [
           key,
@@ -64883,7 +65481,7 @@ function createTypedValueNormalizer(rows, document, childrenByContainerId, param
         ])
       );
     } else {
-      value = normalizeLiteral(row.value);
+      value = normalizeTypedLiteral(row.value, typeInfo);
     }
     const normalized = {
       ...typeof row.classId === "string" ? { classId: row.classId } : {},
@@ -64917,7 +65515,7 @@ function createTypedValueNormalizer(rows, document, childrenByContainerId, param
     return normalized;
   };
   const normalizeClassValue = (row, typeInfo) => {
-    if (!isStringRecord2(row.value)) return normalizeLiteral(row.value);
+    if (!isStringRecord3(row.value)) return normalizeLiteral(row.value);
     const effectiveClassId = row.classId ?? (typeInfo.type === 7 /* Class */ ? typeInfo.classId : void 0);
     if (effectiveClassId === void 0) return normalizeLiteral(row.value);
     const env = rowGenericEnvironment(document, row);
@@ -64952,7 +65550,10 @@ function createTypedValueNormalizer(rows, document, childrenByContainerId, param
       Object.entries(constructorArgs).map(([parameterId, value]) => {
         const typeInfo = parameterTypes.get(parameterId);
         if (typeInfo === void 0 || !isAggregateTypeInfo(typeInfo) || typeof value !== "string") {
-          return [parameterId, normalizeLiteral(value)];
+          return [
+            parameterId,
+            typeInfo === void 0 ? normalizeLiteral(value) : normalizeTypedLiteral(value, typeInfo)
+          ];
         }
         return [parameterId, normalizeTypedRow(value, typeInfo)];
       })
@@ -65002,7 +65603,7 @@ function collectSoftOwnedConstructorArgumentValueIds(index, ownerValueId, preser
           collectTypedRow(childId, typeInfo.entryTypeInfo);
         }
       }
-    } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord2(row.value)) {
+    } else if (typeInfo.type === 5 /* Dictionary */ && isStringRecord3(row.value)) {
       for (const childId of Object.values(row.value)) {
         collectTypedRow(childId, typeInfo.entryTypeInfo);
       }
@@ -65024,7 +65625,7 @@ function collectSoftOwnedConstructorArgumentValueIds(index, ownerValueId, preser
     collectNestedConstructorArguments(valueId);
   };
   const collectClassChildren = (row, typeInfo) => {
-    if (!isStringRecord2(row.value)) return;
+    if (!isStringRecord3(row.value)) return;
     const effectiveClassId = row.classId ?? (typeInfo.type === 7 /* Class */ ? typeInfo.classId : void 0);
     if (effectiveClassId === void 0) return;
     const env = rowGenericEnvironment(index.document, row);
@@ -65093,7 +65694,7 @@ function tryMemberTypeInfo(document, rawMember, env) {
 function isAggregateTypeInfo(typeInfo) {
   return typeInfo.type === 7 /* Class */ || typeInfo.type === 22 /* Interface */ || typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */;
 }
-function isStringRecord2(value) {
+function isStringRecord3(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return false;
   }
@@ -65118,7 +65719,10 @@ var init_constructor_argument_ownership = __esm({
     "use strict";
     init_members();
     init_inheritance();
+    init_constructor_parameter_settlement();
+    init_constructors2();
     init_generics();
+    init_core();
     init_compile_ns_property();
     init_value_row_owner_members();
     MaterializedValueGraphContext = class {
@@ -65136,6 +65740,7 @@ var init_constructor_argument_ownership = __esm({
       membersById;
       constructorsById;
       parameterTypesByValueId = /* @__PURE__ */ new Map();
+      settleConstructorParameter;
       aggregateTypeByTargetValueId = /* @__PURE__ */ new Map();
       typedNormalizer;
       ownership;
@@ -65194,9 +65799,8 @@ var init_constructor_argument_ownership = __esm({
         if (typeof root.classId !== "string") {
           return result;
         }
-        const schemaClass2 = this.classesById.get(root.classId);
-        const constructorId = root.instanceConstructorId !== void 0 ? root.instanceConstructorId : schemaClass2?.requiredConstructorId;
-        if (constructorId === void 0 || constructorId === null) {
+        const constructorId = root.instanceConstructorId;
+        if (typeof constructorId !== "string") {
           return result;
         }
         const constructor2 = this.constructorsById.get(constructorId);
@@ -65232,6 +65836,49 @@ var init_constructor_argument_ownership = __esm({
         }
         return edges;
       }
+      /** Schema field whose declared initializer one aggregate constructor argument settles. */
+      constructorArgumentOwnerPlacement(edge) {
+        const owner = this.valuesById.get(edge.ownerValueId);
+        if (owner === void 0) return void 0;
+        if (typeof owner.classId !== "string") return void 0;
+        if (typeof owner.instanceConstructorId !== "string") return void 0;
+        const constructor2 = this.constructorsById.get(owner.instanceConstructorId);
+        if (constructor2 === void 0) return void 0;
+        if (constructor2.classId !== owner.classId) return void 0;
+        const parameterIndex = constructor2.argumentTypes.findIndex(
+          (_, index) => constructorActionParameterId(constructor2, index) === edge.parameterId
+        );
+        if (parameterIndex === -1) return void 0;
+        const parameter4 = constructor2.argumentTypes[parameterIndex];
+        if (parameter4 === void 0) return void 0;
+        this.settleConstructorParameter ??= createConstructorSettlementResolver(
+          this.document
+        );
+        const settled = this.settleConstructorParameter(
+          owner.classId,
+          parameter4.name,
+          owner.instanceConstructorId
+        );
+        if (settled === null) return void 0;
+        const member = this.membersById.get(settled.memberId);
+        if (member === void 0) return void 0;
+        try {
+          return {
+            ...settled,
+            member: substituteMember(
+              member,
+              rowGenericEnvironment(this.document, owner),
+              this.document.members
+            )
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      /** Member whose declared initializer one aggregate constructor argument settles. */
+      constructorArgumentOwnerMember(edge) {
+        return this.constructorArgumentOwnerPlacement(edge)?.member;
+      }
       normalizeConstructorArguments(constructorArgs, root) {
         return this.normalizer().normalizeConstructorArgs(constructorArgs, root);
       }
@@ -67939,6 +68586,10 @@ function parameterDefaultRuntimeValue(parameter4, subject) {
   if (parameter4.type === 8 /* Enum */) return [defaultValue.value];
   return defaultValue.value;
 }
+function parameterDefaultsAsFullArguments(argumentTypes, subject) {
+  if (!argumentTypes.every(parameterHasDefault)) return null;
+  return fillTrailingParameterDefaults([], argumentTypes, subject);
+}
 function fillCallableCallSiteArguments(args, member, ctx) {
   if (member === null) return args;
   if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
@@ -73115,15 +73766,21 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   deleteRuntimeSessionValue(ctx, rootRow.id);
   ctx.__executionState?.constructorGroups.delete(rootRow.id);
   const constructorArgs = typeof result.value === "object" && result.value !== null ? ctx.__constructedArgumentsByValue.get(result.value) : void 0;
+  const provenance = pickInstanceProvenance({
+    constructorArgs,
+    instanceConstructorId: rootRow.instanceConstructorId,
+    instanceVariantId: rootRow.instanceVariantId,
+    instanceVariantRowValueId: rootRow.instanceVariantRowValueId
+  });
   return {
     value: result.value,
     classId: rootRow.classId ?? null,
     ...rootRow.genericBindings === void 0 ? {} : { genericBindings: { ...rootRow.genericBindings } },
     provisionalRootId: rootRow.id,
-    ...constructorArgs === void 0 ? {} : { constructorArgs: deepClonePlainData(constructorArgs) },
-    ...rootRow.instanceConstructorId === void 0 ? {} : { instanceConstructorId: rootRow.instanceConstructorId },
-    ...rootRow.instanceVariantId === void 0 ? {} : { instanceVariantId: rootRow.instanceVariantId },
-    ...rootRow.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: rootRow.instanceVariantRowValueId }
+    ...provenance,
+    ...provenance.constructorArgs === void 0 ? {} : {
+      constructorArgs: deepClonePlainData(provenance.constructorArgs)
+    }
   };
 }
 function encodeLookupInitializerResult(member, value, created, ctx) {
@@ -75304,6 +75961,14 @@ function buildStoredValuePlacementIndex(args) {
   for (const entries of unorderedEntriesByContainerId.values()) {
     entries.sort((left, right) => left.id.localeCompare(right.id));
   }
+  const constructorsById = new Map(
+    args.constructors.map((constructor2) => [constructor2.id, constructor2])
+  );
+  const resolveConstructorSettlement = createConstructorSettlementResolver({
+    classes: args.classes,
+    constructors: args.constructors,
+    members: args.members
+  });
   const resolvedMemberById = /* @__PURE__ */ new Map();
   const resolvedMember = (member) => {
     const cached = resolvedMemberById.get(member.id);
@@ -75377,10 +76042,30 @@ function buildStoredValuePlacementIndex(args) {
     if (isMemberClassBase(member)) {
       const classId = value.classId ?? member.classId;
       appendPlacement(mutablePlacementsByClassId, classId, placement);
-      if (!isStringRecord3(value.value)) continue;
+      if (!isLiteralValueContent(value) || !isStringRecord4(value.value)) {
+        continue;
+      }
+      const settledChildrenBySchemaKey = /* @__PURE__ */ new Map();
+      const constructor2 = typeof value.instanceConstructorId === "string" ? constructorsById.get(value.instanceConstructorId) : void 0;
+      if (constructor2 !== void 0 && constructor2.classId === classId && value.constructorArgs != null) {
+        for (const [index, parameter4] of constructor2.argumentTypes.entries()) {
+          const settled = resolveConstructorSettlement(
+            classId,
+            parameter4.name,
+            constructor2.id
+          );
+          if (settled === null || Object.hasOwn(value.value, settled.schemaKey)) {
+            continue;
+          }
+          const childValueId = value.constructorArgs[constructorActionParameterId(constructor2, index)];
+          if (typeof childValueId === "string" && valuesById.has(childValueId)) {
+            settledChildrenBySchemaKey.set(settled.schemaKey, childValueId);
+          }
+        }
+      }
       for (const entry of storedSchema(classId)) {
         const childMember = membersById2.get(entry.memberId);
-        const childValueId = value.value[entry.schemaKey];
+        const childValueId = value.value[entry.schemaKey] ?? settledChildrenBySchemaKey.get(entry.schemaKey);
         if (childMember === void 0 || typeof childValueId !== "string") {
           continue;
         }
@@ -75400,7 +76085,7 @@ function buildStoredValuePlacementIndex(args) {
     const entryMember = membersById2.get(member.entryMemberId);
     if (entryMember === void 0) continue;
     if (isMemberDictionaryBase(member)) {
-      if (!isStringRecord3(value.value)) continue;
+      if (!isStringRecord4(value.value)) continue;
       for (const [key, childValueId] of Object.entries(value.value)) {
         queue.push({
           memberId: entryMember.id,
@@ -75448,7 +76133,7 @@ function appendPlacement(index, key, placement) {
     placements.push(placement);
   }
 }
-function isStringRecord3(value) {
+function isStringRecord4(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
@@ -75458,6 +76143,8 @@ var init_stored_value_placement_index = __esm({
   "../src/models/members/stored-value-placement-index.ts"() {
     "use strict";
     init_inheritance();
+    init_constructor_parameter_settlement();
+    init_constructors2();
     init_project2();
     init_member_kinds();
   }
@@ -75747,6 +76434,46 @@ function resolveVirtualInstanceGraph(args) {
     (args.materializedRows ?? args.document.values).map((row) => [row.id, row])
   );
   const materializedRows = [...materializedById.values()];
+  const materializedGraph = args.materializedGraph ?? new MaterializedValueGraphContext(
+    { ...args.document, values: materializedRows },
+    materializedById
+  );
+  const constructorsById = new Map(
+    (args.document.constructors ?? []).map((constructor2) => [
+      constructor2.id,
+      constructor2
+    ])
+  );
+  const resolveConstructorSettlement = createConstructorSettlementResolver({
+    classes: args.document.classes,
+    constructors: args.document.constructors ?? [],
+    members: args.document.members
+  });
+  const settledAggregateChildren = (row, classId) => {
+    if (!isLiteralValueContent(row)) return /* @__PURE__ */ new Map();
+    if (typeof row.instanceConstructorId !== "string") return /* @__PURE__ */ new Map();
+    const constructor2 = constructorsById.get(row.instanceConstructorId);
+    if (constructor2 === void 0) return /* @__PURE__ */ new Map();
+    const edgeByParameterId = new Map(
+      materializedGraph.constructorEdges(row).map((edge) => [edge.parameterId, edge])
+    );
+    const result = /* @__PURE__ */ new Map();
+    for (const [index, parameter4] of constructor2.argumentTypes.entries()) {
+      const edge = edgeByParameterId.get(
+        constructorActionParameterId(constructor2, index)
+      );
+      if (edge === void 0) continue;
+      const settled = resolveConstructorSettlement(
+        classId,
+        parameter4.name,
+        row.instanceConstructorId
+      );
+      if (settled !== null) {
+        result.set(settled.schemaKey, edge.targetValueId);
+      }
+    }
+    return result;
+  };
   const materializedUnorderedEntryIdsByContainerId = buildUnorderedListMembershipIndex(materializedRows);
   const readMaterializedRow = (valueId) => {
     recorder?.recordValueRead(valueId);
@@ -75791,8 +76518,9 @@ function resolveVirtualInstanceGraph(args) {
     };
     if (isMemberClassBase(indexed.member) && effective.value !== null) {
       const storedRecord = stringRecord2(materialized?.value);
-      const effectiveRecord = {};
       const classId = effective.classId ?? indexed.member.classId;
+      const constructedChildren = materialized === null ? /* @__PURE__ */ new Map() : settledAggregateChildren(materialized, classId);
+      const effectiveRecord = {};
       const schema = mergeStoredInstanceSchema(
         classId,
         args.document.classes,
@@ -75804,7 +76532,7 @@ function resolveVirtualInstanceGraph(args) {
           schemaKey: entry.schemaKey
         });
         if (!expansion.nodesByPath.has(childPath)) continue;
-        const storedChildId = storedRecord[entry.schemaKey] ?? null;
+        const storedChildId = storedRecord[entry.schemaKey] ?? constructedChildren.get(entry.schemaKey) ?? null;
         const child = resolvePath(childPath, storedChildId, effectiveId);
         effectiveRecord[entry.schemaKey] = child.id;
       }
@@ -76619,21 +77347,24 @@ function sparsifyConstructedInstance(args) {
     args.constructed.root,
     ...args.constructed.createdChildren
   ];
+  const constructionDocument = {
+    ...args.document,
+    values: materializedRows
+  };
+  const materializedGraph = new MaterializedValueGraphContext(
+    constructionDocument
+  );
   const graph = resolveVirtualInstanceGraph({
     document: args.document,
     instanceRoot: args.constructed.root,
     rootMember: args.rootMember,
     expandedRoot: args.baseline.root,
     expandedRows: [args.baseline.root, ...args.baseline.createdChildren],
-    materializedRows
+    materializedRows,
+    materializedGraph
   });
   const protectedValueIds = /* @__PURE__ */ new Set();
-  const constructionDocument = {
-    ...args.document,
-    values: materializedRows
-  };
-  for (const edge of constructorArgumentAggregateEdgesForValue(
-    constructionDocument,
+  for (const edge of materializedGraph.constructorEdges(
     args.constructed.root
   )) {
     protectedValueIds.add(edge.targetValueId);
@@ -76658,7 +77389,9 @@ function sparsifyConstructedInstance(args) {
     (row) => !deletedIds.has(row.id)
   );
   const nextIdById = /* @__PURE__ */ new Map();
+  const claimedVirtualIds = /* @__PURE__ */ new Map();
   for (const location3 of graph.locationsByPath.values()) {
+    claimedVirtualIds.set(location3.virtualRow.id, location3.pathKey);
     const real = location3.materializedRow;
     if (real === null || deletedIds.has(real.id)) continue;
     nextIdById.set(
@@ -76670,6 +77403,36 @@ function sparsifyConstructedInstance(args) {
     );
   }
   nextIdById.set(args.constructed.root.id, args.constructed.root.id);
+  const unmappedRows = retainedRows.filter((row) => !nextIdById.has(row.id));
+  const fallbackRows = (unmappedRows.length === 0 ? [] : (() => {
+    const fallbackPaths = materializedFallbackPaths(
+      materializedRows,
+      graph,
+      materializedGraph
+    );
+    return unmappedRows.flatMap((row) => {
+      const path = fallbackPaths.get(row.id);
+      return path === void 0 ? [] : [{ row, path }];
+    });
+  })()).sort(
+    (left, right) => left.path.localeCompare(right.path) || left.row.id.localeCompare(right.row.id)
+  );
+  for (const { row, path } of fallbackRows) {
+    const rawSourceIdentity = typeof row.sourceValueId === "string" && row.sourceValueId.length > 0 ? row.sourceValueId : `materialized:${path}`;
+    const { sourceIdentity: sourceIdentity3, virtualId } = claimVirtualIdentity({
+      claimedVirtualIds,
+      instanceRootId: args.constructed.root.id,
+      rawSourceIdentity,
+      pathKey: path
+    });
+    nextIdById.set(
+      row.id,
+      args.virtualValueIdForSource?.(
+        args.constructed.root.id,
+        sourceIdentity3
+      ) ?? virtualId
+    );
+  }
   const remap = (value) => {
     if (typeof value === "string") return nextIdById.get(value) ?? value;
     if (Array.isArray(value)) return value.map(remap);
@@ -76696,6 +77459,70 @@ function sparsifyConstructedInstance(args) {
   }
   return { root, createdChildren };
 }
+function materializedFallbackPaths(rows, graph, materializedGraph) {
+  const rowsById = new Map(rows.map((row) => [row.id, row]));
+  const unorderedEntriesByContainerId = buildUnorderedListMembershipIndex(rows);
+  const paths = /* @__PURE__ */ new Map();
+  for (const location3 of graph.locationsByPath.values()) {
+    if (location3.materializedRow !== null) {
+      paths.set(location3.materializedRow.id, location3.pathKey);
+    }
+  }
+  paths.set(graph.instanceRootId, ROOT_PATH);
+  let frontier = [...paths.keys()];
+  while (frontier.length > 0) {
+    const candidates = [];
+    for (const parentId of frontier) {
+      const row = rowsById.get(parentId);
+      const parentPath = paths.get(parentId);
+      if (row === void 0 || parentPath === void 0) continue;
+      if (Array.isArray(row.value)) {
+        row.value.forEach((childId, index) => {
+          if (typeof childId !== "string" || !rowsById.has(childId)) return;
+          candidates.push([
+            childId,
+            appendPath(parentPath, { kind: "list", index })
+          ]);
+        });
+      } else if (row.value !== null && typeof row.value === "object") {
+        for (const [schemaKey, childId] of Object.entries(row.value)) {
+          if (typeof childId !== "string" || !rowsById.has(childId)) continue;
+          candidates.push([
+            childId,
+            appendPath(parentPath, { kind: "class", schemaKey })
+          ]);
+        }
+      }
+      for (const [index, childId] of (unorderedEntriesByContainerId.get(row.id) ?? []).filter((childId2) => rowsById.has(childId2)).sort((left, right) => left.localeCompare(right)).entries()) {
+        candidates.push([
+          childId,
+          appendPath(parentPath, { kind: "list", index })
+        ]);
+      }
+      for (const edge of materializedGraph.edgesByOwnerValueId.get(row.id) ?? []) {
+        if (!rowsById.has(edge.targetValueId)) continue;
+        candidates.push([
+          edge.targetValueId,
+          appendPath(parentPath, {
+            kind: "class",
+            schemaKey: `@constructor:${edge.parameterId}`
+          })
+        ]);
+      }
+    }
+    candidates.sort(
+      (left, right) => left[1].localeCompare(right[1]) || left[0].localeCompare(right[0])
+    );
+    const nextFrontier = [];
+    for (const [childId, path] of candidates) {
+      if (paths.has(childId)) continue;
+      paths.set(childId, path);
+      nextFrontier.push(childId);
+    }
+    frontier = nextFrontier;
+  }
+  return paths;
+}
 function closeClassArgumentsFromRowStamp(member, row) {
   if (!isMemberClassBase(member)) return member;
   const stamp = row.genericBindings;
@@ -77359,6 +78186,7 @@ function resolveVariantInstanceGraphForDocument(args) {
 function variantSwapDeclaredMember(document, rootValueId) {
   const placement = buildStoredValuePlacementIndex({
     classes: document.classes,
+    constructors: document.constructors ?? [],
     members: document.members,
     project: document.project,
     resolveStaticValueId: (memberId) => document.members.find((member) => member.id === memberId)?.valueId ?? null,
@@ -77372,6 +78200,7 @@ function createHeadlessVirtualInstanceResolver(args) {
   let placementByValueId = null;
   const placements = () => placementByValueId ??= buildStoredValuePlacementIndex({
     classes: document.classes,
+    constructors: document.constructors ?? [],
     members: document.members,
     project: document.project,
     resolveStaticValueId: (memberId) => document.members.find((member) => member.id === memberId)?.valueId ?? null,
@@ -77463,6 +78292,7 @@ var init_virtual_instance_values = __esm({
     "use strict";
     init_deep_clone_plain_data();
     init_inheritance();
+    init_constructor_parameter_settlement();
     init_generics();
     init_members();
     init_member_value_id();
@@ -77472,6 +78302,7 @@ var init_virtual_instance_values = __esm({
     init_neoscript();
     init_init_backed_value_materialization();
     init_constructor_argument_ownership();
+    init_constructors2();
     init_src();
     KEPT_ROW_SAMPLE_LIMIT = 12;
     CORPUS_SCANNING_MEMBER_KINDS = /* @__PURE__ */ new Set([
@@ -77671,16 +78502,22 @@ function evaluateMemberInitializer(args) {
   // origin or the recipe reads as a historical unrecorded overload.
   rootRow.constructorArgs ?? void 0;
   const pinnedRootSchemaKeys = typeof result.value === "object" && result.value !== null ? ctx.__constructedFieldSchemaKeysByValue?.get(result.value) : void 0;
+  const provenance = pickInstanceProvenance({
+    constructorArgs,
+    instanceConstructorId: rootRow.instanceConstructorId,
+    instanceVariantId: rootRow.instanceVariantId,
+    instanceVariantRowValueId: rootRow.instanceVariantRowValueId
+  });
   return {
     value: result.value,
     classId: rootRow.classId ?? null,
     ...rootRow.genericBindings === void 0 ? {} : { genericBindings: { ...rootRow.genericBindings } },
     ...pinnedRootSchemaKeys === void 0 ? {} : { pinnedRootSchemaKeys },
     provisionalRootId: rootRow.id,
-    ...constructorArgs === void 0 ? {} : { constructorArgs: deepClonePlainData(constructorArgs) },
-    ...rootRow.instanceConstructorId === void 0 ? {} : { instanceConstructorId: rootRow.instanceConstructorId },
-    ...rootRow.instanceVariantId === void 0 ? {} : { instanceVariantId: rootRow.instanceVariantId },
-    ...rootRow.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: rootRow.instanceVariantRowValueId }
+    ...provenance,
+    ...provenance.constructorArgs === void 0 ? {} : {
+      constructorArgs: deepClonePlainData(provenance.constructorArgs)
+    }
   };
 }
 var evaluatorLookupsByDocument;
@@ -77688,6 +78525,7 @@ var init_evaluateInitializer = __esm({
   "../src/view-models/neoscript-evaluator/evaluateInitializer.ts"() {
     "use strict";
     init_deep_clone_plain_data();
+    init_instance_provenance();
     init_members();
     init_project2();
     init_NSGetterRuntimeError();
@@ -77708,6 +78546,26 @@ var init_neoscript_evaluator = __esm({
 });
 
 // ../src/database/init-backed-value-materialization.ts
+function declarationInitializerContext(document) {
+  const cached = declarationInitializerContextByDocument.get(document);
+  if (cached !== void 0) return cached;
+  const initializerValueIds = new Set(
+    document.values.filter(isInitValueContent).map((value) => value.id)
+  );
+  const valuesById = new Map(
+    document.values.map((value) => [value.id, value])
+  );
+  const rootOwners = /* @__PURE__ */ new Map();
+  resolveOwnerMembersForValues(
+    document,
+    initializerValueIds,
+    void 0,
+    rootOwners
+  );
+  const created = { valuesById, rootOwners };
+  declarationInitializerContextByDocument.set(document, created);
+  return created;
+}
 function evaluateInitializerMaterialization(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
@@ -77797,6 +78655,36 @@ function materializeInitializerValue(args) {
 function materializeMemberDefaultValue(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
+  const { valuesById, rootOwners } = declarationInitializerContext(
+    args.document
+  );
+  const declarationArguments = (member, init, sourceValueId) => {
+    const ownerClass = typeof sourceValueId === "string" ? initializerOwnerContext(
+      args.document,
+      sourceValueId,
+      rootOwners,
+      valuesById
+    ).ownerClass : typeof Reflect.get(member, "id") === "string" ? findSchemaPlacement(
+      String(Reflect.get(member, "id")),
+      args.document.classes
+    )?.ownerClass ?? null : null;
+    if (ownerClass === null) return [];
+    const constructorId = ownerClass.requiredConstructorId;
+    if (typeof constructorId !== "string") return [];
+    const constructor2 = args.document.constructors?.find(
+      (candidate) => candidate.id === constructorId
+    );
+    if (constructor2 === void 0) return [];
+    const defaults = parameterDefaultsAsFullArguments(
+      constructor2.argumentTypes,
+      `Declaration template on '${ownerClass.name}'`
+    );
+    if (defaults !== null) return defaults;
+    const parameterNames = new Set(
+      constructor2.argumentTypes.map((argument2) => argument2.name)
+    );
+    return initializerReferencesAnyIdentifier(init.code, parameterNames) ? [] : constructor2.argumentTypes.map(() => null);
+  };
   const built = buildDefaultMemberValue({
     document: args.document,
     projectId: args.envelope.projectId,
@@ -77806,11 +78694,17 @@ function materializeMemberDefaultValue(args) {
     ...args.genericEnv === void 0 ? {} : { genericEnv: args.genericEnv },
     // A declaration default may itself be init-backed one level down (P43 §2),
     // and those nested initializers must evaluate against the same document.
-    initEvaluator: (member, init) => evaluateMemberInitializer({
+    initEvaluator: (member, init, sourceValueId) => evaluateMemberInitializer({
       init,
       member,
       document: args.document,
-      createdValues
+      createdValues,
+      storedConstructionReplay: true,
+      argumentValues: declarationArguments(
+        member,
+        init,
+        sourceValueId ?? null
+      )
     })
   });
   const interior = createdValues.filter((created) => created.id !== built.id);
@@ -77831,165 +78725,18 @@ function materializeMemberDefaultValue(args) {
   });
   return { root, createdValues: interior, pinnedRootSchemaKeys: /* @__PURE__ */ new Set() };
 }
+var declarationInitializerContextByDocument;
 var init_init_backed_value_materialization = __esm({
   "../src/database/init-backed-value-materialization.ts"() {
     "use strict";
     init_deep_clone_plain_data();
     init_members();
+    init_inheritance();
     init_neoscript_evaluator();
-  }
-});
-
-// ../src/models/constructors/constructors.ts
-function hasRejectedConstructorKey(value) {
-  return REJECTED_CONSTRUCTOR_KEYS.some((key) => value[key] !== void 0);
-}
-function isNamedBaseClauseEntry(value, nameIsValid) {
-  if (typeof value !== "object" || value === null) return false;
-  if (Array.isArray(value)) return false;
-  const candidate = value;
-  if (!Object.keys(candidate).every((key) => key === "name" || key === "code")) {
-    return false;
-  }
-  if (!nameIsValid(candidate.name)) return false;
-  if (typeof candidate.code !== "string") return false;
-  return candidate.code.length > 0;
-}
-function isNeoConstructorBaseArgument(value) {
-  return isNamedBaseClauseEntry(value, isValidCallableArgumentIdentifier);
-}
-function isNeoConstructorBaseInitializerField(value) {
-  return isNamedBaseClauseEntry(value, isValidSchemaMemberIdentifier);
-}
-function isNeoClassConstructorBase(value) {
-  if (typeof value !== "object" || value === null) return false;
-  if (Array.isArray(value)) return false;
-  const v = value;
-  if (hasRejectedConstructorKey(v)) return false;
-  if (!isValidDocsText(v.docsText)) return false;
-  if (typeof v.classId !== "string") return false;
-  if (v.classId.length === 0) return false;
-  if (typeof v.code !== "string" && v.code !== null) return false;
-  if (!Array.isArray(v.argumentTypes)) return false;
-  const parameterNames = /* @__PURE__ */ new Set();
-  const argumentTypes = [];
-  for (const argument2 of v.argumentTypes) {
-    if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
-    if (!isValidCallableArgumentIdentifier(argument2.name)) return false;
-    if (parameterNames.has(argument2.name)) return false;
-    parameterNames.add(argument2.name);
-    argumentTypes.push(argument2);
-  }
-  if (validateParameterDefaults(argumentTypes).length > 0) return false;
-  if (v.baseArguments !== void 0 && v.baseArguments !== null) {
-    if (!Array.isArray(v.baseArguments)) return false;
-    const baseNames = /* @__PURE__ */ new Set();
-    for (const baseArgument of v.baseArguments) {
-      if (!isNeoConstructorBaseArgument(baseArgument)) return false;
-      if (baseNames.has(baseArgument.name)) return false;
-      baseNames.add(baseArgument.name);
-    }
-  }
-  if (v.baseInitializerFields !== void 0 && v.baseInitializerFields !== null) {
-    if (!Array.isArray(v.baseInitializerFields)) return false;
-    const fieldNames = /* @__PURE__ */ new Set();
-    for (const field of v.baseInitializerFields) {
-      if (!isNeoConstructorBaseInitializerField(field)) return false;
-      if (fieldNames.has(field.name)) return false;
-      fieldNames.add(field.name);
-    }
-  }
-  if (v.action !== void 0 && v.action !== null) return false;
-  if (v.compiledBaseArguments !== void 0 && v.compiledBaseArguments !== null) {
-    return false;
-  }
-  return v.compiledBaseInitializerFields === void 0 || v.compiledBaseInitializerFields === null;
-}
-function isUncompiledNeoClassConstructor(value) {
-  if (!isNeoClassConstructorBase(value)) return false;
-  const v = value;
-  if (typeof v.id !== "string" || v.id.length === 0) return false;
-  if (typeof v.projectId !== "string" || v.projectId.length === 0) return false;
-  if (!isEpochMillis(v.createdAt)) return false;
-  return isEpochMillis(v.updatedAt);
-}
-function hasValidConstructorAction(action, argumentTypes) {
-  if (!isNSFunctionWithReturnType(action)) return false;
-  if (action.typeInfo.type !== 0 /* Null */) return false;
-  if (action.typeInfo.required !== true) return false;
-  if (action.parameters.length !== argumentTypes.length + 2) return false;
-  if (action.parameters[0]?.id !== "__this__") return false;
-  if (action.parameters[1]?.id !== "__root__") return false;
-  for (let index = 0; index < argumentTypes.length; index += 1) {
-    const parameter4 = action.parameters[index + 2];
-    if (parameter4?.id !== `__arg_${index}__`) return false;
-    const declared = argumentTypes[index];
-    if (declared === void 0) return false;
-    if (!typeInfosInvariantlyEqual(parameter4.typeInfo, declared)) return false;
-  }
-  return true;
-}
-function compiledBaseClauseGettersAlign(compiled, authored) {
-  const authoredCount = Array.isArray(authored) ? authored.length : 0;
-  if (compiled === void 0 || compiled === null) return authoredCount === 0;
-  if (!Array.isArray(compiled)) return false;
-  if (!compiled.every(isNSGetter)) return false;
-  return compiled.length === authoredCount;
-}
-function isNeoClassConstructorProps(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value;
-  const {
-    action: _action,
-    compiledBaseArguments: _compiledBaseArguments,
-    compiledBaseInitializerFields: _compiledBaseInitializerFields,
-    ...authored
-  } = v;
-  void _action;
-  void _compiledBaseArguments;
-  void _compiledBaseInitializerFields;
-  if (!isNeoClassConstructorBase(authored)) return false;
-  if (typeof v.id !== "string") return false;
-  if (v.id.length === 0) return false;
-  if (typeof v.projectId !== "string") return false;
-  if (!isEpochMillis(v.createdAt)) return false;
-  if (!isEpochMillis(v.updatedAt)) return false;
-  const argumentTypes = v.argumentTypes;
-  if (!hasValidConstructorAction(v.action, argumentTypes)) return false;
-  if (!compiledBaseClauseGettersAlign(v.compiledBaseArguments, v.baseArguments)) {
-    return false;
-  }
-  return compiledBaseClauseGettersAlign(
-    v.compiledBaseInitializerFields,
-    v.baseInitializerFields
-  );
-}
-function isNeoClassConstructor(value) {
-  return isNeoClassConstructorProps(value);
-}
-var REJECTED_CONSTRUCTOR_KEYS;
-var init_constructors = __esm({
-  "../src/models/constructors/constructors.ts"() {
-    "use strict";
-    init_core();
-    init_docs_text2();
-    init_member_kinds();
-    init_schema_identifiers();
-    init_neoscript();
-    REJECTED_CONSTRUCTOR_KEYS = [
-      "bodyMode",
-      "uiAction",
-      "returnTypeInfo",
-      "deferred"
-    ];
-  }
-});
-
-// ../src/models/constructors/index.ts
-var init_constructors2 = __esm({
-  "../src/models/constructors/index.ts"() {
-    "use strict";
-    init_constructors();
+    init_evaluateNSGetter();
+    init_value_row_owner_members();
+    init_compile_ns_property();
+    declarationInitializerContextByDocument = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -83099,6 +83846,11 @@ function quote4(value) {
 }
 function resolveRootPathCollectionValuesV4(args) {
   const resolved = /* @__PURE__ */ new Map();
+  const placements = prospectiveStoredValuePlacements(
+    args.state,
+    args.registry,
+    args.manifest
+  );
   for (const member of args.manifest.members) {
     if (member.kind !== "lookup") continue;
     const spelled = member.collectionValueId;
@@ -83117,13 +83869,24 @@ function resolveRootPathCollectionValuesV4(args) {
         }
       });
     };
-    const target = walkRootValuePath(path, args.state, args.registry, fail);
+    const target = walkRootValuePath(
+      path,
+      args.state,
+      args.registry,
+      placements,
+      fail
+    );
     if (target !== null) resolved.set(member.id, target);
   }
   return resolved;
 }
 function resolveRootPathVariantFolderCollectionValuesV4(args) {
   const resolved = /* @__PURE__ */ new Map();
+  const placements = prospectiveStoredValuePlacements(
+    args.state,
+    args.registry,
+    args.manifest
+  );
   for (const folder of args.manifest.variantFolders) {
     const spelled = folder.binding?.collectionValueId;
     if (typeof spelled !== "string") continue;
@@ -83141,12 +83904,18 @@ function resolveRootPathVariantFolderCollectionValuesV4(args) {
         }
       });
     };
-    const target = walkRootValuePath(path, args.state, args.registry, fail);
+    const target = walkRootValuePath(
+      path,
+      args.state,
+      args.registry,
+      placements,
+      fail
+    );
     if (target !== null) resolved.set(folder.id, target);
   }
   return resolved;
 }
-function walkRootValuePath(path, state, registry, fail) {
+function walkRootValuePath(path, state, registry, placements, fail) {
   const segments = path.split(".");
   const slotName = segments[1];
   if (segments[0] !== "root" || slotName === void 0) {
@@ -83191,7 +83960,7 @@ function walkRootValuePath(path, state, registry, fail) {
       );
       return null;
     }
-    const next = body[segment];
+    const next = placements.childrenByParentValueId.get(cursor)?.get(segment)?.childValueId;
     if (typeof next !== "string") {
       const cursorData = state[`value:${cursor}`]?.data;
       const collapsed = isObjectRecord2(cursorData) && isVirtualInstanceRootShape(cursorData);
@@ -83204,6 +83973,62 @@ function walkRootValuePath(path, state, registry, fail) {
   }
   return cursor;
 }
+function prospectiveStoredValuePlacements(state, registry, manifest) {
+  const records2 = new Map(
+    Object.values(state).map((record3) => [
+      `${record3.recordKind}:${record3.recordId}`,
+      record3
+    ])
+  );
+  for (const row of registry.pendingValues.values()) {
+    records2.set(`value:${row.id}`, {
+      recordKind: "value",
+      recordId: row.id,
+      contentHash: "pending",
+      data: row
+    });
+  }
+  for (const schemaClass2 of manifest.classes) {
+    const key = `class:${schemaClass2.id}`;
+    records2.set(key, {
+      recordKind: "class",
+      recordId: schemaClass2.id,
+      contentHash: "pending",
+      data: schemaClass2
+    });
+  }
+  for (const member of manifest.members) {
+    const key = `member:${member.id}`;
+    records2.set(key, {
+      recordKind: "member",
+      recordId: member.id,
+      contentHash: "pending",
+      data: member
+    });
+  }
+  for (const constructor2 of manifest.constructors) {
+    const key = `constructor:${constructor2.id}`;
+    const current = records2.get(key)?.data;
+    records2.set(key, {
+      recordKind: "constructor",
+      recordId: constructor2.id,
+      contentHash: "pending",
+      data: isObjectRecord2(current) && current.action !== void 0 ? current : {
+        ...constructor2,
+        argumentTypes: constructor2.arguments
+      }
+    });
+  }
+  for (const variant of manifest.variants ?? []) {
+    records2.set(`variant:${variant.id}`, {
+      recordKind: "variant",
+      recordId: variant.id,
+      contentHash: "pending",
+      data: variant
+    });
+  }
+  return buildStoredValuePlacementIndexV4(records2.values());
+}
 var ROOT_PROJECT_FIELDS2, ROOT_PATH_PENDING_PREFIX;
 var init_root_source = __esm({
   "src/project-source/root-source.ts"() {
@@ -83214,6 +84039,7 @@ var init_root_source = __esm({
     init_value_sources();
     init_root_value_paths();
     init_source_format();
+    init_stored_value_placements();
     ROOT_PROJECT_FIELDS2 = [
       "rootAssetsMemberId",
       "rootSaveFileMemberId",
@@ -84620,13 +85446,21 @@ function storedConstructionEmitters(state, manifest) {
     }
     candidateRoots.add(record3.recordId);
   }
-  const owners = resolveOwnerMembersForValues(
-    readPulledProjectDocumentV4(records2),
-    candidateRoots
+  const document = readPulledProjectDocumentV4(records2);
+  const owners = resolveOwnerMembersForValues(document, candidateRoots);
+  const storedPlacements = buildStoredValuePlacementIndexV4(records2.values());
+  const membersById2 = new Map(
+    document.members.map((member) => [member.id, member])
   );
+  for (const valueId of candidateRoots) {
+    if (owners.has(valueId)) continue;
+    const memberId = storedPlacements.placementByChildValueId.get(valueId)?.memberId;
+    const member = memberId === null || memberId === void 0 ? void 0 : membersById2.get(memberId);
+    if (member !== void 0) owners.set(valueId, member);
+  }
   const probe = createStoredConstructionProbeV4(records2, manifest);
   let parents;
-  const parentByChildId = () => parents ??= storedValueParentIndex(records2);
+  const parentByChildId = () => parents ??= storedValueParentIndex(records2, storedPlacements);
   const root = (valueId) => {
     const member = owners.get(valueId);
     return member === void 0 ? void 0 : {
@@ -84663,7 +85497,7 @@ function storedConstructionEmitters(state, manifest) {
     }
   };
 }
-function storedValueParentIndex(records2) {
+function storedValueParentIndex(records2, placements) {
   const parents = /* @__PURE__ */ new Map();
   const valueIds = /* @__PURE__ */ new Set();
   for (const record3 of records2.values()) {
@@ -84692,6 +85526,12 @@ function storedValueParentIndex(records2) {
       }
     }
   }
+  for (const edge of placements.placementByChildValueId.values()) {
+    if (edge.source !== "constructor") continue;
+    if (!parents.has(edge.childValueId)) {
+      parents.set(edge.childValueId, edge.parentValueId);
+    }
+  }
   return parents;
 }
 function nearestOwnedAncestor(valueId, parents, owners) {
@@ -84787,6 +85627,7 @@ var init_materialized_construction_cache = __esm({
     init_value_row_owner_members();
     init_instance_provenance();
     init_value_sources();
+    init_stored_value_placements();
     MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH = ".neo/build/materialized-constructions-v1.json";
     MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION = 2;
   }
@@ -84922,7 +85763,7 @@ function collectVariantGraphValueIds(args) {
   if (roots.length === 0) return collected;
   const rootMemberIds2 = new Set(roots.map((root) => root.member.id));
   const rootOwners = /* @__PURE__ */ new Map();
-  resolveOwnerMembersForValues(
+  resolveSemanticOwnerMembersForValues(
     document,
     new Set(document.values.map((value) => value.id)),
     roots,
@@ -84939,7 +85780,7 @@ var init_variant_value_graph = __esm({
     "use strict";
     init_members();
     init_core();
-    init_value_row_owner_members();
+    init_constructor_argument_ownership();
   }
 });
 
@@ -85092,7 +85933,7 @@ function collectNeoScriptRecompileTargets(args) {
       args.postDocument.variants ?? []
     );
     if (transactionImpactsAnyOwnerMember(scope, impactedIds)) {
-      const ownerByValueId = resolveOwnerMembersForValues(
+      const ownerByValueId = resolveSemanticOwnerMembersForValues(
         scope.document,
         new Set(postValues.map((record3) => record3.id)),
         scope.roots
@@ -85549,7 +86390,7 @@ function collectImpactedSourceNames(args) {
       (document.values ?? []).filter((value) => isImpactedRecordId(value.id)).map((value) => value.id)
     );
     const scope = withVariantOwnershipRoots(document, document.variants ?? []);
-    const ownerByValueId = resolveOwnerMembersForValues(
+    const ownerByValueId = resolveSemanticOwnerMembersForValues(
       scope.document,
       impactedValueIds,
       scope.roots
@@ -85738,7 +86579,7 @@ var init_neo_script_recompile_scope = __esm({
     init_inheritance();
     init_effective_storage();
     init_project_root_members();
-    init_value_row_owner_members();
+    init_constructor_argument_ownership();
     NON_CONTRACT_MEMBER_FIELDS = /* @__PURE__ */ new Set([
       "createdAt",
       "updatedAt",
@@ -86074,12 +86915,10 @@ function materializedInitializerReconciliationFailuresV4(args) {
           rootMember: owner
         });
       } catch (error) {
-        if (!(error instanceof VirtualExpansionUnsupportedError)) {
-          throw new Error(
-            `Resolving the stored instance graph of value "${reconciliation.valueId}" failed: ${error instanceof Error ? error.message : String(error)}`,
-            { cause: error }
-          );
-        }
+        throw new Error(
+          `Resolving the canonical stored instance graph of value "${reconciliation.valueId}" failed: ${error instanceof Error ? error.message : String(error)}`,
+          { cause: error }
+        );
       }
     }
     const currentNormalized = currentRoot === void 0 ? void 0 : new MaterializedValueGraphContext(
@@ -86173,7 +87012,7 @@ function materializeInitializersLocallyV4(args) {
   );
   let document = variantScope.document;
   const rootKinds = /* @__PURE__ */ new Map();
-  const rootOwners = resolveOwnerMembersForValues(
+  const rootOwners = resolveSemanticOwnerMembersForValues(
     document,
     sourceRoots,
     variantScope.roots,
@@ -86181,7 +87020,7 @@ function materializeInitializersLocallyV4(args) {
     rootKinds
   );
   const roots = [];
-  for (const sourceValueId of sourceRoots) {
+  for (const sourceValueId of [...sourceRoots].sort()) {
     if (rootKinds.get(sourceValueId) === "declaration") continue;
     const rootOwner = rootOwners.get(sourceValueId);
     if (rootOwner === void 0) {
@@ -86464,6 +87303,7 @@ var init_local_initializer_materialization = __esm({
     init_initializer_replay();
     init_members();
     init_constructor_argument_ownership();
+    init_constructor_argument_ownership();
     init_value_row_owner_members();
     init_variant_value_graph();
     init_neo_script_recompile_scope();
@@ -88449,7 +89289,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       );
     }
   }
-  const resolveMember3 = (member) => {
+  const resolveMember4 = (member) => {
     const chain = [];
     const seen = /* @__PURE__ */ new Set();
     let current = member;
@@ -88506,7 +89346,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     }
     if (member.isReadOnly !== true) continue;
     const placements = placementsByMemberId.get(member.id) ?? [];
-    const resolved = resolveMember3(member);
+    const resolved = resolveMember4(member);
     if (placements.length === 0) {
       throw new Error(
         `Read-only member "${member.name}" (${member.id}) has no owning class and must have at least one direct class-schema owner.`
@@ -88562,7 +89402,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       const visitKey = `${rawOwned.id}\0${environmentKey}`;
       if (visited.has(visitKey)) return;
       visited.add(visitKey);
-      const inherited = resolveMember3(rawOwned);
+      const inherited = resolveMember4(rawOwned);
       let owned = inherited;
       if (inherited.kind === 21) {
         const visitedParams = /* @__PURE__ */ new Set();
@@ -88590,7 +89430,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
               `Read-only member "${member.name}" has an owned Generic member "${inherited.name}" bound to missing member "${bindingId}"; ${ownerLabel}.`
             );
           }
-          owned = resolveMember3(binding);
+          owned = resolveMember4(binding);
         }
         owned = { ...owned, id: rawOwned.id, name: inherited.name };
         if (inherited.storage === void 0) delete owned.storage;
@@ -88737,7 +89577,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   );
   const visitedValueIds = /* @__PURE__ */ new Set();
   const inspectValueBody = (rawMember, body, classId, ownerValueId) => {
-    const inspectedMember = resolveMember3(rawMember);
+    const inspectedMember = resolveMember4(rawMember);
     if (inspectedMember.kind === 9) {
       assertNoPersistedReadOnlySyntheticLookupId2(
         body,
@@ -88873,14 +89713,14 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     return env;
   }
   function substituteMemberForClass(member, schemaClass2) {
-    const resolved = resolveMember3(member);
+    const resolved = resolveMember4(member);
     const env = genericEnvForClass(schemaClass2);
     if (resolved.kind === 21 && typeof resolved.genericParamId === "string") {
       const bindingId = env.get(resolved.genericParamId);
       const binding = bindingId ? membersById2.get(bindingId) : void 0;
       if (!binding) return resolved;
       const substituted = {
-        ...resolveMember3(binding),
+        ...resolveMember4(binding),
         id: member.id,
         name: resolved.name
       };
@@ -90061,46 +90901,6 @@ var init_project_schema_identifier_validation = __esm({
   }
 });
 
-// ../src/database/constructor-parameter-settlement.ts
-function constructorSettledSchemaEntry(view, classId, parameterName) {
-  const membersById2 = new Map(
-    view.members.map((member) => [member.id, member])
-  );
-  const visited = /* @__PURE__ */ new Set();
-  let currentId = classId;
-  while (currentId !== null && !visited.has(currentId)) {
-    visited.add(currentId);
-    const schemaClass2 = view.classes.find(
-      (candidate) => candidate.id === currentId
-    );
-    if (schemaClass2 === void 0) return null;
-    for (const [schemaKey, memberId] of Object.entries(
-      schemaClass2.schema ?? {}
-    )) {
-      if (typeof memberId !== "string") continue;
-      const member = membersById2.get(memberId);
-      const defaultRecord = asRecord(member?.defaultValue);
-      const initRecord = asRecord(defaultRecord?.init);
-      if (initRecord !== null && typeof initRecord.code === "string" && initRecord.code.trim() === parameterName) {
-        return { schemaKey, memberId };
-      }
-    }
-    currentId = schemaClass2.extendsClassId ?? null;
-  }
-  return null;
-}
-function asRecord(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return null;
-  }
-  return value;
-}
-var init_constructor_parameter_settlement = __esm({
-  "../src/database/constructor-parameter-settlement.ts"() {
-    "use strict";
-  }
-});
-
 // ../src/database/project-document-value-overlay.ts
 function overlayCreatedValues(documentValues, createdValues) {
   if (createdValues.length === 0) return [...documentValues];
@@ -90431,6 +91231,363 @@ var init_member_access_modifier_validation = __esm({
   }
 });
 
+// ../src/models/search/universal-search-projection.ts
+function truncateUtf8(value, maxBytes) {
+  if (value === void 0) return "";
+  if (!Number.isInteger(maxBytes) || maxBytes < 0) {
+    throw new Error(
+      "UTF-8 truncation maxBytes must be a non-negative integer."
+    );
+  }
+  if (value.length <= maxBytes && isAscii(value)) return value;
+  if (utf8Encoder.encode(value).byteLength <= maxBytes) return value;
+  let result = "";
+  let bytes = 0;
+  for (const character of value) {
+    const characterBytes = utf8Encoder.encode(character).byteLength;
+    if (bytes + characterBytes > maxBytes) break;
+    result += character;
+    bytes += characterBytes;
+  }
+  return result.trimEnd();
+}
+function isAscii(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (value.charCodeAt(index) > 127) return false;
+  }
+  return true;
+}
+var utf8Encoder;
+var init_universal_search_projection = __esm({
+  "../src/models/search/universal-search-projection.ts"() {
+    "use strict";
+    utf8Encoder = new TextEncoder();
+  }
+});
+
+// ../convex/valueHeadPlacementGraph.ts
+function projectValueHeadPlacementGraph(args) {
+  const members = recordMap(args.members);
+  const classes = recordMap(args.classes);
+  const values = recordMap(args.values);
+  const resolvedMembers = /* @__PURE__ */ new Map();
+  const effectiveSchemas = /* @__PURE__ */ new Map();
+  const resolvedMember = (member) => {
+    const id2 = requireId(member, "member");
+    const cached = resolvedMembers.get(id2);
+    if (cached !== void 0) return cached;
+    const resolved = resolveMember3(member, members);
+    resolvedMembers.set(id2, resolved);
+    return resolved;
+  };
+  const effectiveSchema = (classId) => {
+    const cached = effectiveSchemas.get(classId);
+    if (cached !== void 0) return cached;
+    const schema = resolveClassSchema(classId, classes);
+    effectiveSchemas.set(classId, schema);
+    return schema;
+  };
+  const unorderedByContainer = /* @__PURE__ */ new Map();
+  for (const value of values.values()) {
+    if (typeof value.containerId !== "string") continue;
+    const members2 = unorderedByContainer.get(value.containerId) ?? [];
+    members2.push(requireId(value, "value"));
+    unorderedByContainer.set(value.containerId, members2);
+  }
+  const constructorEdgesByOwner = /* @__PURE__ */ new Map();
+  for (const edge of args.constructorEdges ?? []) {
+    const edges = constructorEdgesByOwner.get(edge.ownerValueId) ?? [];
+    edges.push(edge);
+    constructorEdgesByOwner.set(edge.ownerValueId, edges);
+  }
+  const result = /* @__PURE__ */ new Map();
+  const constructorOriginByValueId = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const root of args.rootMembers) {
+    const member = members.get(root.id);
+    if (member === void 0 || typeof member.valueId !== "string") continue;
+    queue.push({
+      valueId: member.valueId,
+      memberId: root.id,
+      parentRecordKind: "member",
+      parentRecordId: root.id,
+      relation: "memberValue",
+      scope: "authored",
+      ownerId: null,
+      rootMemberId: root.id,
+      path: root.label
+    });
+  }
+  for (const root of args.variantRoots ?? []) {
+    queue.push({
+      valueId: root.valueId,
+      memberId: null,
+      parentRecordKind: "variant",
+      parentRecordId: root.variantId,
+      relation: "variantValue",
+      scope: "variant",
+      ownerId: null,
+      rootMemberId: null,
+      path: null
+    });
+  }
+  for (const member of members.values()) {
+    if (!isRecord8(member.defaultValue)) continue;
+    for (const child of directChildEdges({
+      member: resolvedMember(member),
+      body: member.defaultValue.value,
+      unorderedByContainer,
+      parentValueId: null,
+      effectiveSchema
+    })) {
+      queue.push({
+        valueId: child.valueId,
+        memberId: child.memberId,
+        parentRecordKind: "member",
+        parentRecordId: requireId(member, "member"),
+        relation: "memberDefault",
+        scope: "memberDefault",
+        ownerId: null,
+        rootMemberId: null,
+        path: null
+      });
+    }
+  }
+  for (let cursor = 0; cursor < queue.length; cursor += 1) {
+    const item = queue[cursor];
+    if (item === void 0) continue;
+    const value = values.get(item.valueId);
+    if (value === void 0) continue;
+    const explicitClassId = stringOrNull(value.classId);
+    const rootlessMember = item.memberId === null && explicitClassId !== null ? {
+      id: `variant-root:${item.valueId}`,
+      kind: 7,
+      classId: explicitClassId
+    } : null;
+    const storedMember = item.memberId === null ? void 0 : members.get(item.memberId);
+    if (rootlessMember === null && storedMember === void 0) continue;
+    const member = rootlessMember ?? resolvedMember(storedMember);
+    const classId = explicitClassId ?? (member.kind === 7 ? stringOrNull(member.classId) : null);
+    const ownerId = classId === null ? item.ownerId : item.valueId;
+    const schemaClass2 = classId === null ? void 0 : classes.get(classId);
+    const projection = {
+      valueMemberId: item.memberId,
+      parentRecordKind: item.parentRecordKind,
+      parentRecordId: item.parentRecordId,
+      parentRelation: item.relation,
+      valuePlacementScope: item.scope,
+      valueOwnerId: ownerId,
+      valueRootMemberId: item.rootMemberId,
+      valueClassId: classId,
+      valueSearchClassName: schemaClass2 !== void 0 && typeof schemaClass2.name === "string" ? truncateUtf8(schemaClass2.name, 512) : null,
+      valueSearchPlacementPath: item.path,
+      ...item.constructorParameterId === void 0 ? {} : { constructorParameterId: item.constructorParameterId },
+      ...item.constructorSchemaKey === void 0 ? {} : { constructorSchemaKey: item.constructorSchemaKey }
+    };
+    const existing = result.get(item.valueId);
+    if (existing !== void 0) {
+      const existingConstructorOrigin = constructorOriginByValueId.get(item.valueId) === true;
+      const projectionConstructorOrigin = item.constructorOrigin === true;
+      if (!placementsEqual(existing, projection) || existingConstructorOrigin !== projectionConstructorOrigin) {
+        if (existing.valuePlacementScope === "memberDefault" && projection.valuePlacementScope === "authored") {
+        } else if (existing.valuePlacementScope === "authored" && projection.valuePlacementScope === "memberDefault") {
+          continue;
+        } else if (existing.valuePlacementScope !== "standalone" && projection.valuePlacementScope === "standalone") {
+          continue;
+        } else if (existing.valuePlacementScope === "standalone" && projection.valuePlacementScope !== "standalone") {
+        } else if (existingConstructorOrigin !== projectionConstructorOrigin) {
+          if (!existingConstructorOrigin) continue;
+        } else if (existing.parentRelation !== "unorderedCollectionEntry" && projection.parentRelation === "unorderedCollectionEntry") {
+          continue;
+        } else if (existing.parentRelation === "unorderedCollectionEntry" && projection.parentRelation !== "unorderedCollectionEntry") {
+        } else if (existing.parentRecordKind === "member" && existing.parentRelation === "memberValue" && existing.valuePlacementScope === "authored") {
+          continue;
+        } else {
+          throw new Error(
+            `Value "${item.valueId}" has ambiguous containment parents "${existing.parentRecordId ?? "none"}" and "${item.parentRecordId}".`
+          );
+        }
+      } else {
+        continue;
+      }
+    }
+    result.set(item.valueId, projection);
+    constructorOriginByValueId.set(
+      item.valueId,
+      item.constructorOrigin === true
+    );
+    for (const child of directChildEdges({
+      member,
+      body: value.value,
+      unorderedByContainer,
+      parentValueId: item.valueId,
+      classId,
+      effectiveSchema
+    })) {
+      const childMember = members.get(child.memberId);
+      const childName = childMember === void 0 ? null : stringOrNull(resolvedMember(childMember).name);
+      queue.push({
+        valueId: child.valueId,
+        memberId: child.memberId,
+        parentRecordKind: "value",
+        parentRecordId: item.valueId,
+        relation: child.relation,
+        scope: item.scope,
+        ownerId,
+        rootMemberId: item.rootMemberId,
+        path: child.relation === "classField" && childName !== null ? joinPath(item.path, childName) : item.path,
+        constructorOrigin: item.constructorOrigin
+      });
+    }
+    for (const edge of constructorEdgesByOwner.get(item.valueId) ?? []) {
+      const childMember = members.get(edge.memberId);
+      const childName = childMember === void 0 ? null : stringOrNull(resolvedMember(childMember).name);
+      queue.push({
+        valueId: edge.targetValueId,
+        memberId: edge.memberId,
+        parentRecordKind: "value",
+        parentRecordId: item.valueId,
+        relation: "classField",
+        scope: item.scope,
+        ownerId,
+        rootMemberId: item.rootMemberId,
+        path: childName === null ? item.path : joinPath(item.path, childName),
+        constructorOrigin: true,
+        constructorParameterId: edge.parameterId,
+        constructorSchemaKey: edge.schemaKey
+      });
+    }
+  }
+  for (const [valueId, value] of values) {
+    if (result.has(valueId)) continue;
+    const classId = stringOrNull(value.classId);
+    const schemaClass2 = classId === null ? void 0 : classes.get(classId);
+    result.set(valueId, {
+      valueMemberId: null,
+      parentRecordKind: null,
+      parentRecordId: null,
+      parentRelation: null,
+      valuePlacementScope: "standalone",
+      valueOwnerId: classId === null ? null : valueId,
+      valueRootMemberId: null,
+      valueClassId: classId,
+      valueSearchClassName: schemaClass2 !== void 0 && typeof schemaClass2.name === "string" ? truncateUtf8(schemaClass2.name, 512) : null,
+      valueSearchPlacementPath: null
+    });
+  }
+  return result;
+}
+function directChildEdges(args) {
+  const result = [];
+  if (args.member.kind === 9) return result;
+  if (args.member.kind === 7) {
+    if (!isRecord8(args.body)) return result;
+    const classId = args.classId ?? stringOrNull(args.member.classId);
+    if (classId === null) return result;
+    const schema = args.effectiveSchema(classId);
+    for (const [schemaKey, valueId] of Object.entries(args.body)) {
+      const memberId = schema.get(schemaKey);
+      if (memberId === void 0 || typeof valueId !== "string") continue;
+      result.push({ valueId, memberId, relation: "classField" });
+    }
+    return result;
+  }
+  const entryMemberId = stringOrNull(args.member.entryMemberId);
+  if (entryMemberId === null) return result;
+  if (args.parentValueId !== null) {
+    for (const valueId of args.unorderedByContainer.get(args.parentValueId) ?? []) {
+      result.push({
+        valueId,
+        memberId: entryMemberId,
+        relation: "unorderedCollectionEntry"
+      });
+    }
+    if (args.member.listKind === "unordered") return result;
+  }
+  const ids = Array.isArray(args.body) ? args.body : isRecord8(args.body) ? Object.values(args.body) : [];
+  for (const valueId of ids) {
+    if (typeof valueId !== "string") continue;
+    result.push({
+      valueId,
+      memberId: entryMemberId,
+      relation: "collectionEntry"
+    });
+  }
+  return result;
+}
+function resolveMember3(source, members) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = source;
+  while (current !== void 0) {
+    const id2 = requireId(current, "member");
+    if (visited.has(id2))
+      throw new Error(`Member inheritance cycle at "${id2}".`);
+    visited.add(id2);
+    chain.unshift(current);
+    const baseId = stringOrNull(current.extendsMemberId);
+    current = baseId === null ? void 0 : members.get(baseId);
+  }
+  const result = {};
+  for (const layer of chain) {
+    for (const [key, value] of Object.entries(layer)) {
+      if (value !== void 0) result[key] = value;
+    }
+  }
+  return result;
+}
+function resolveClassSchema(classId, classes) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = classes.get(classId);
+  while (current !== void 0) {
+    const id2 = requireId(current, "class");
+    if (visited.has(id2)) throw new Error(`Class inheritance cycle at "${id2}".`);
+    visited.add(id2);
+    chain.unshift(current);
+    const baseId = stringOrNull(current.extendsClassId);
+    current = baseId === null ? void 0 : classes.get(baseId);
+  }
+  const schema = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of chain) {
+    if (!isRecord8(schemaClass2.schema)) continue;
+    for (const [key, memberId] of Object.entries(schemaClass2.schema)) {
+      if (typeof memberId === "string") schema.set(key, memberId);
+    }
+  }
+  return schema;
+}
+function recordMap(values) {
+  const result = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (!isRecord8(value)) continue;
+    result.set(requireId(value, "record"), value);
+  }
+  return result;
+}
+function requireId(value, kind) {
+  if (typeof value.id === "string" && value.id.length > 0) return value.id;
+  throw new Error(`Placement ${kind} record is missing a stable id.`);
+}
+function stringOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function joinPath(parent, child) {
+  return truncateUtf8(parent === null ? child : `${parent} > ${child}`, 512);
+}
+function placementsEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_valueHeadPlacementGraph = __esm({
+  "../convex/valueHeadPlacementGraph.ts"() {
+    "use strict";
+    init_universal_search_projection();
+  }
+});
+
 // ../src/database/project-migration-created-values.ts
 function validateCreatedMigrationGraph(args) {
   if (args.createdSessionValues.length === 0) return [];
@@ -90546,7 +91703,7 @@ function validateCreatedMigrationGraph(args) {
       if (row.value === null && member !== void 0 && isMemberClassBase(member) && !member.required) {
         return;
       }
-      if (!isRecord8(row.value)) {
+      if (!isRecord9(row.value)) {
         throw graphError(
           args,
           `Class value "${valueId}" does not contain a record`
@@ -90612,7 +91769,7 @@ function validateCreatedMigrationGraph(args) {
           `Dictionary value "${valueId}" references missing entry member "${member.entryMemberId}"`
         );
       }
-      if (!isRecord8(row.value)) {
+      if (!isRecord9(row.value)) {
         throw graphError(args, `Dictionary value "${valueId}" is not a record`);
       }
       for (const [key, childId] of Object.entries(row.value)) {
@@ -90656,7 +91813,7 @@ function validateCreatedMigrationGraph(args) {
   }
   return [...createdById.values()];
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function graphError(args, detail) {
@@ -90931,14 +92088,14 @@ function findParentValues(valueId, values) {
       }
       continue;
     }
-    if (!isStringRecord4(value.value)) continue;
+    if (!isStringRecord5(value.value)) continue;
     for (const [key, childValueId] of Object.entries(value.value)) {
       if (childValueId === valueId) parents.push({ value, key });
     }
   }
   return parents;
 }
-function isStringRecord4(value) {
+function isStringRecord5(value) {
   if (typeof value !== "object") return false;
   if (value === null) return false;
   if (Array.isArray(value)) return false;
@@ -91956,7 +93113,7 @@ function assertNumberRange(member, value, path) {
     throw new Error(`${path} must be at most ${max}.`);
   }
 }
-function isStringRecord5(value) {
+function isStringRecord6(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
@@ -92351,7 +93508,7 @@ var init_project_version_static_value_writes = __esm({
         if (!isLiteralValueContent(args.value)) {
           throw new Error(`${args.path} must store a literal Class value.`);
         }
-        if (!isStringRecord5(args.value.value)) {
+        if (!isStringRecord6(args.value.value)) {
           throw new Error(`${args.path} must store a Class schema-key map.`);
         }
         const effectiveClassId = args.value.classId ?? args.member.classId;
@@ -92508,7 +93665,7 @@ var init_project_version_static_value_writes = __esm({
         }
       }
       validateDictionary(args) {
-        if (!isStringRecord5(args.value.value)) {
+        if (!isStringRecord6(args.value.value)) {
           throw new Error(`${args.path} must store a Dictionary key/value-id map.`);
         }
         const entryRecord = this.memberById.get(args.member.entryMemberId);
@@ -92610,7 +93767,7 @@ var init_project_version_static_value_writes = __esm({
       }
       collectOwnedBody(args) {
         const member = resolveMember2(args.member, this.document.members);
-        if (isMemberClassBase(member) && isStringRecord5(args.body)) {
+        if (isMemberClassBase(member) && isStringRecord6(args.body)) {
           const effectiveClassId = args.classId ?? member.classId;
           const env = resolveInstanceEnv(
             effectiveClassId,
@@ -92657,7 +93814,7 @@ var init_project_version_static_value_writes = __esm({
           }
           return;
         }
-        if (isMemberDictionaryBase(member) && isStringRecord5(args.body)) {
+        if (isMemberDictionaryBase(member) && isStringRecord6(args.body)) {
           const entryRecord = this.memberById.get(member.entryMemberId);
           if (entryRecord === void 0) return;
           const entryMember = substituteMember(
@@ -92823,7 +93980,7 @@ function materializeLocalizableStringWriteChanges(args) {
     )
   );
   if (valueChangeIds.size === 0) return changes;
-  const owners = resolveOwnerMembersForValues(
+  const owners = resolveSemanticOwnerMembersForValues(
     args.postDocument,
     valueChangeIds
   );
@@ -92847,7 +94004,7 @@ function materializeLocalizableStringWriteChanges(args) {
       if (member === void 0) continue;
       additionalRoots.push({ member, valueId: rootId });
     }
-    const additionalOwners = resolveOwnerMembersForValues(
+    const additionalOwners = resolveSemanticOwnerMembersForValues(
       args.postDocument,
       valueChangeIds,
       additionalRoots
@@ -92998,7 +94155,7 @@ var init_localizable_member_value_writes = __esm({
     init_localization2();
     init_members();
     init_project_version_intents();
-    init_value_row_owner_members();
+    init_constructor_argument_ownership();
   }
 });
 
@@ -93352,7 +94509,7 @@ function prepareServerOwnedSchemaCommit(args) {
     contentHashHeads: args.contentHashHeads
   });
   const serverMintedBindingMemberIds = /* @__PURE__ */ new Set();
-  materializeAuthoredValueSeeds({
+  const pendingConstructedGraphValidations = materializeAuthoredValueSeeds({
     document: applyProjectVersionWriteChanges(postDocument, prepared),
     prepared,
     authoredValueSeeds: args.authoredValueSeeds ?? [],
@@ -93383,6 +94540,11 @@ function prepareServerOwnedSchemaCommit(args) {
       document: applyProjectVersionWriteChanges(args.document, prepared)
     });
   }
+  drainConstructedGraphValidations({
+    document: args.document,
+    prepared,
+    pending: pendingConstructedGraphValidations
+  });
   prepareServerOwnedDelegateValueBodies({
     document: args.document,
     postDocument,
@@ -93409,11 +94571,69 @@ function prepareServerOwnedSchemaCommit(args) {
     document: committedDocument,
     prepared
   });
+  attachPreparedValuePlacements(prepared, committedDocument);
   attachPreparedConstructorAggregateEdges(prepared, committedDocument);
   return orderVariantRootValuesWithVariants(
     orderDeclaredMemberCreatesFirst(prepared, postDocument)
   );
 }
+function attachPreparedValuePlacements(prepared, document) {
+  const creates = prepared.filter(
+    (change) => change.recordKind === "value" && change.operation === "create"
+  );
+  if (creates.length === 0) return;
+  const materializedGraph = new MaterializedValueGraphContext(document);
+  const constructorEdges = [];
+  for (const edges of materializedGraph.edgesByOwnerValueId.values()) {
+    for (const edge of edges) {
+      if (materializedGraph.referenceCountByTargetValueId.get(
+        edge.targetValueId
+      ) !== 1 || materializedGraph.independentlyOwnedValueIds.has(edge.targetValueId)) {
+        continue;
+      }
+      const owner = materializedGraph.constructorArgumentOwnerPlacement(edge);
+      if (owner === void 0) continue;
+      constructorEdges.push({
+        ownerValueId: edge.ownerValueId,
+        targetValueId: edge.targetValueId,
+        memberId: owner.memberId,
+        parameterId: edge.parameterId,
+        schemaKey: owner.schemaKey
+      });
+    }
+  }
+  const placements = projectValueHeadPlacementGraph({
+    rootMembers: [
+      { id: document.project.rootAssetsMemberId, label: "Assets" },
+      { id: document.project.rootSaveFileMemberId, label: "Save" },
+      { id: document.project.rootSessionMemberId, label: "Session" }
+    ],
+    variantRoots: (document.variants ?? []).map((variant) => ({
+      variantId: variant.id,
+      valueId: variant.valueId
+    })),
+    members: document.members,
+    classes: document.classes,
+    values: document.values,
+    constructorEdges
+  });
+  for (const change of creates) {
+    const placement = placements.get(change.recordId);
+    if (placement === void 0) continue;
+    change.serverValuePlacement = {
+      valueMemberId: placement.valueMemberId,
+      parentRecordKind: placement.parentRecordKind,
+      parentRecordId: placement.parentRecordId,
+      parentRelation: placement.parentRelation,
+      valuePlacementScope: placement.valuePlacementScope,
+      valueOwnerId: placement.valueOwnerId,
+      valueRootMemberId: placement.valueRootMemberId,
+      valueClassId: placement.valueClassId,
+      valueSearchClassName: placement.valueSearchClassName,
+      valueSearchPlacementPath: placement.valueSearchPlacementPath
+    };
+  }
+}
 function attachPreparedConstructorAggregateEdges(prepared, document) {
   const valueChanges = prepared.filter(
     (change) => change.recordKind === "value" && change.operation !== "delete"
@@ -93496,16 +94716,13 @@ function materializePreparedInstanceInitializers(args) {
     compiledDocument,
     compiledDocument.variants ?? []
   );
-  const owners = resolveOwnerMembersForValues(
+  const owners = resolveSemanticOwnerMembersForValues(
     materializationScope.document,
     new Set(sites.keys()),
     materializationScope.roots,
     void 0,
     rootKinds
   );
-  const variantRootValueIds = new Set(
-    materializationScope.roots.map((root) => root.valueId)
-  );
   const replayOnlyIndexes = [];
   for (const [valueId, site] of sites) {
     const existingRoot = existingValueById.get(valueId);
@@ -93520,12 +94737,15 @@ function materializePreparedInstanceInitializers(args) {
       );
     }
     const materialized = materializeInitializerValue({
-      // The scope document, so the evaluator can close `NeoVariant<TObject>`
-      // through the same synthetic binding member the ownership walk used.
+      // Every site that survives the declaration-default guard is source for
+      // a persisted instance construction. The trusted replay mode both
+      // admits Immutable storage and installs the concrete generic slot; the
+      // CLI uses the same mode on the first push, so it cannot be conditional
+      // on a literal row already existing.
       document: materializationScope.document,
       member,
       row: site.row,
-      ...existingConstructedRoot || variantRootValueIds.has(valueId) ? { storedConstructionReplay: true } : {}
+      storedConstructionReplay: true
     });
     if (existingConstructedRoot) {
       if (!isLiteralValueContent(materialized.root) || existingRoot.classId !== materialized.root.classId || !replayedCreationDataMatches({
@@ -93551,7 +94771,7 @@ function materializePreparedInstanceInitializers(args) {
         init: withoutInitializerConstructionFields(site.row.init)
       },
       constructionBaselineReplay: true,
-      ...variantRootValueIds.has(valueId) ? { storedConstructionReplay: true } : {}
+      storedConstructionReplay: true
     });
     const sparse = sparsifyConstructedInstance({
       document: materializationScope.document,
@@ -94532,8 +95752,12 @@ function appendDerivedDialogueChanges(args) {
 }
 function drainConstructedGraphValidations(args) {
   if (args.pending.length === 0) return;
+  const postDocument = applyProjectVersionWriteChanges(
+    args.document,
+    args.prepared
+  );
   const sameTransactionValues = new Map(
-    args.document.values.map((value) => [value.id, value])
+    postDocument.values.map((value) => [value.id, value])
   );
   for (const change of args.prepared) {
     if (change.recordKind !== "value") continue;
@@ -94548,8 +95772,17 @@ function drainConstructedGraphValidations(args) {
     );
   }
   for (const validation of args.pending) {
+    const validationDocument = {
+      ...postDocument,
+      localizedTexts: validation.document.localizedTexts
+    };
+    const member = validationDocument.members.find(
+      (candidate) => candidate.id === validation.member.id
+    ) ?? validation.member;
     validateConstructedStaticValueGraph({
       ...validation,
+      document: validationDocument,
+      member,
       sameTransactionValues
     });
   }
@@ -94587,9 +95820,57 @@ function hasLiveMemberChange(prepared) {
     (change) => change.recordKind === "member" && change.operation !== "delete" && change.nextData !== void 0
   );
 }
+function withProspectiveAuthoredSeedValues(document, seeds) {
+  const prospective = [];
+  const envelope = {
+    projectId: document.project.id,
+    createdAt: 0,
+    updatedAt: 0
+  };
+  for (const seed of seeds) {
+    if (seed.valueId !== void 0 && !isAuthoredValueSeedInitContent(seed)) {
+      prospective.push({
+        ...envelope,
+        id: seed.valueId,
+        value: structuredClone(seed.value),
+        ...typeof seed.classId === "string" ? { classId: seed.classId } : {},
+        ...pickInstanceProvenance(seed)
+      });
+    }
+    for (const row of seed.values ?? []) {
+      if (isAuthoredValueSeedInitContent(row)) continue;
+      prospective.push({
+        ...envelope,
+        id: row.id,
+        value: structuredClone(row.value),
+        ...typeof row.classId === "string" ? { classId: row.classId } : {},
+        ...row.containerId === void 0 ? {} : { containerId: row.containerId },
+        ...row.genericBindings === void 0 ? {} : { genericBindings: { ...row.genericBindings } },
+        ...row.sourceValueId === void 0 ? {} : { sourceValueId: row.sourceValueId },
+        ...pickInstanceProvenance(row)
+      });
+    }
+  }
+  if (prospective.length === 0) return document;
+  const seedByMemberId = new Map(
+    seeds.filter((seed) => typeof seed.valueId === "string").map((seed) => [seed.memberId, seed])
+  );
+  return {
+    ...document,
+    members: document.members.map((member) => {
+      const seed = seedByMemberId.get(member.id);
+      if (seed?.valueId === void 0) return member;
+      if (member.isStatic !== true && !isProjectRootMember(document.project, member.id)) {
+        return member;
+      }
+      return { ...member, valueId: seed.valueId };
+    }),
+    values: overlayCreatedValues(document.values, prospective)
+  };
+}
 function materializeAuthoredValueSeeds(args) {
   if (args.authoredValueSeeds.length === 0 && !hasLiveMemberChange(args.prepared)) {
-    return;
+    return [];
   }
   const pendingGraphValidations = [];
   materializeStaticSeedBindingMembers(args);
@@ -94600,6 +95881,10 @@ function materializeAuthoredValueSeeds(args) {
   if (seedByMemberId.size !== args.authoredValueSeeds.length) {
     throw new Error("Schema commit contains duplicate member value seeds.");
   }
+  const evaluationDocument = withProspectiveAuthoredSeedValues(
+    args.document,
+    args.authoredValueSeeds
+  );
   const consumedSeedMemberIds = /* @__PURE__ */ new Set();
   for (let index = 0; index < args.prepared.length; index += 1) {
     const change = args.prepared[index];
@@ -94612,7 +95897,7 @@ function materializeAuthoredValueSeeds(args) {
       if (seed === void 0) continue;
       consumedSeedMemberIds.add(member.id);
       materializeInstanceDefaultSeed({
-        document: args.document,
+        document: evaluationDocument,
         documentIndex,
         prepared: args.prepared,
         pendingGraphValidations,
@@ -94668,10 +95953,10 @@ function materializeAuthoredValueSeeds(args) {
       ...seed === void 0 ? {} : { defaultValue: seedValueContent(seed) }
     };
     const materialized = seed?.values === void 0 && (seed === void 0 || !isAuthoredValueSeedInitContent(seed)) ? materializeDefaultStaticSeed({
-      document: args.document,
+      document: evaluationDocument,
       member: materializationMember
     }) : materializeAuthoredStaticSeed({
-      document: args.document,
+      document: evaluationDocument,
       documentIndex,
       member: materializationMember,
       // P61 must leave a computed static root as an init-backed prepared
@@ -94770,7 +96055,7 @@ function materializeAuthoredValueSeeds(args) {
     const member = documentIndex.membersById.get(seed.memberId);
     if (member !== void 0 && member.isStatic !== true && !isProjectRootMember(args.document.project, member.id)) {
       materializeInstanceDefaultSeed({
-        document: args.document,
+        document: evaluationDocument,
         documentIndex,
         prepared: args.prepared,
         pendingGraphValidations,
@@ -94782,7 +96067,7 @@ function materializeAuthoredValueSeeds(args) {
       continue;
     }
     materializeExistingAuthoredValueSeed({
-      document: args.document,
+      document: evaluationDocument,
       documentIndex,
       prepared: args.prepared,
       pendingGraphValidations,
@@ -94791,11 +96076,7 @@ function materializeAuthoredValueSeeds(args) {
     });
     consumedSeedMemberIds.add(seed.memberId);
   }
-  drainConstructedGraphValidations({
-    document: args.document,
-    prepared: args.prepared,
-    pending: pendingGraphValidations
-  });
+  return pendingGraphValidations;
 }
 function materializeExistingAuthoredValueSeed(args) {
   const member = args.documentIndex.membersById.get(args.seed.memberId);
@@ -95873,7 +97154,7 @@ function collectTouchedInitializerSites(args) {
     args.document,
     args.document.variants ?? []
   );
-  const ownerByValueId = resolveOwnerMembersForValues(
+  const ownerByValueId = resolveSemanticOwnerMembersForValues(
     initScope.document,
     new Set(initRows.map((row) => row.id)),
     initScope.roots
@@ -95897,19 +97178,18 @@ function collectTouchedInitializerSites(args) {
 function assertProducedGraphLookupsResolve(args) {
   if (args.createdValues.length === 0) return;
   const rootMember = args.produced.classId === null ? args.site.member : { ...args.site.member, classId: args.produced.classId };
-  const graphValues = overlayCreatedValues(
-    args.document.values,
-    args.createdValues
-  );
+  const graphValues = args.createdValues;
   const rootRow = {
     id: `${args.site.label}:root`,
     projectId: args.document.project.id,
     value: args.produced.value,
     classId: args.produced.classId,
+    ...args.produced.constructorArgs === void 0 ? {} : { constructorArgs: args.produced.constructorArgs },
+    ...args.produced.instanceConstructorId === void 0 ? {} : { instanceConstructorId: args.produced.instanceConstructorId },
     createdAt: 0,
     updatedAt: 0
   };
-  const ownerByValueId = resolveOwnerMembersForValues(
+  const ownerByValueId = resolveSemanticOwnerMembersForValues(
     { ...args.document, values: [...graphValues, rootRow] },
     new Set(args.createdValues.map((value) => value.id)),
     [{ member: rootMember, valueId: rootRow.id }]
@@ -95972,7 +97252,7 @@ function prepareServerOwnedValueInitializerBodies(args) {
     committedDocument,
     committedDocument.variants ?? []
   );
-  const ownerByValueId = resolveOwnerMembersForValues(
+  const ownerByValueId = resolveSemanticOwnerMembersForValues(
     initScope.document,
     ownershipTargetIds,
     initScope.roots,
@@ -95988,8 +97268,6 @@ function prepareServerOwnedValueInitializerBodies(args) {
         `Value "${row.id}" carries an initializer but no member in this project version stores it, so its declared type is unknown.`
       );
     }
-    const currentValue = currentValueById.get(row.id);
-    const replaysStoredConstruction = isLiteralValueContent(currentValue) && (typeof currentValue.classId === "string" || currentValue.constructorArgs !== void 0);
     const ownerContext = initializerOwnerContext(
       document,
       row.id,
@@ -96008,8 +97286,12 @@ function prepareServerOwnedValueInitializerBodies(args) {
       valueRow: row,
       valueId: row.id,
       initializerOwnerClass: ownerContext.ownerClass,
-      lexicalThisClass: initializerReferencesLexicalThis(row.init.code) ? ownerContext.lexicalThisClass : null,
-      ...replaysStoredConstruction ? { storedConstructionReplay: true } : {}
+      lexicalThisClass: ownerContext.lexicalThisClass,
+      // A value-row initializer is source for a persisted construction, never
+      // an ad-hoc runtime `new`. The CLI replay compiler uses this same mode;
+      // applying it only after a literal row already existed made the first
+      // push of an Immutable declaration fail while its second push passed.
+      storedConstructionReplay: true
     });
   };
   for (const [index, row] of explicitRows) {
@@ -96123,7 +97405,12 @@ function compileInlineDelegateConstructorArguments(args) {
     );
   }
   const rowConstructorId = row.instanceConstructorId;
-  const constructorId = typeof rowConstructorId === "string" ? rowConstructorId : schemaClass2.requiredConstructorId ?? null;
+  if (typeof rowConstructorId !== "string") {
+    throw new Error(
+      `Value "${row.id}" carries inline delegate constructor arguments without a recorded constructor id.`
+    );
+  }
+  const constructorId = rowConstructorId;
   const constructorRecord = (document.constructors ?? []).find(
     (candidate) => candidate.id === constructorId
   );
@@ -96159,7 +97446,8 @@ function compileInlineDelegateConstructorArguments(args) {
     const settled = constructorSettledSchemaEntry(
       document,
       classId,
-      parameter4.name
+      parameter4.name,
+      constructorRecord.id
     );
     const settledMember = document.members.find(
       (candidate) => candidate.id === settled?.memberId
@@ -96222,7 +97510,7 @@ function prepareServerOwnedDelegateValueBodies(args) {
     committedDocument,
     committedDocument.variants ?? []
   );
-  const ownerByValueId = resolveOwnerMembersForValues(
+  const ownerByValueId = resolveSemanticOwnerMembersForValues(
     delegateScope.document,
     targetIds,
     delegateScope.roots,
@@ -96980,13 +98268,16 @@ function reconcileVariantConstructorArgs(args) {
       if (canonicallyEqual2(rowValue, defaultValue)) continue;
       nextArgs[parameterId] = rowValue;
     }
-    const stampIsMissing = root.instanceConstructorId === void 0;
-    const changed = stampIsMissing || !canonicallyEqual2(existingArgs, nextArgs);
+    if (root.instanceConstructorId !== constructorId) {
+      throw new Error(
+        `Variant root "${root.id}" must record constructor "${constructorId}" before its arguments can be reconciled.`
+      );
+    }
+    const changed = !canonicallyEqual2(existingArgs, nextArgs);
     if (!changed) continue;
     const nextRoot = {
       ...root,
-      constructorArgs: nextArgs,
-      ...stampIsMissing ? { instanceConstructorId: constructorId } : {}
+      constructorArgs: nextArgs
     };
     const existingIndex = changeIndexByValueId.get(root.id);
     if (existingIndex !== void 0) {
@@ -97093,6 +98384,7 @@ var init_project_version_schema_commit = __esm({
     init_project_document_value_overlay();
     init_project2();
     init_member_access_modifier_validation();
+    init_valueHeadPlacementGraph();
     init_variant_value_graph();
     init_variants2();
     init_localization2();
@@ -97115,6 +98407,7 @@ var init_project_version_schema_commit = __esm({
     init_value_row_owner_members();
     init_init_backed_value_materialization();
     init_constructor_argument_ownership();
+    init_constructors2();
     init_dialogue_node_index();
     init_dist_node();
     init_member_value_id();
@@ -97421,7 +98714,10 @@ function assertProtectedValuesNotReplaced(document, changes) {
       candidateValueIds.add(childId);
     }
   }
-  const owners = resolveOwnerMembersForValues(document, candidateValueIds);
+  const owners = resolveSemanticOwnerMembersForValues(
+    document,
+    candidateValueIds
+  );
   for (const valueId of candidateValueIds) {
     const owner = owners.get(valueId);
     if (owner === void 0) continue;
@@ -97520,7 +98816,7 @@ var init_project_version_system_protection_writes = __esm({
     init_project_record_semantics();
     init_system_protection();
     init_system_protection();
-    init_value_row_owner_members();
+    init_constructor_argument_ownership();
     SYSTEM_BEARING_RECORD_KINDS = [
       { recordKind: "member", collection: "members" },
       { recordKind: "class", collection: "classes" },
@@ -97707,7 +99003,7 @@ function toWorldReferenceClassRecord(value) {
   return {
     id: id2,
     extendsClassId: nullableStringField(value, "extendsClassId"),
-    schema: isStringRecord6(value.schema) ? value.schema : void 0,
+    schema: isStringRecord7(value.schema) ? value.schema : void 0,
     system: isPlainRecord4(value.system) ? value.system : null
   };
 }
@@ -97725,7 +99021,7 @@ function worldReferenceValueClassId(value) {
   if (value === void 0) return null;
   return typeof value.classId === "string" && value.classId.length > 0 ? value.classId : null;
 }
-function isStringRecord6(value) {
+function isStringRecord7(value) {
   if (!isPlainRecord4(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
@@ -97785,6 +99081,7 @@ function assertProjectVersionWholeGraphWritesValid(args) {
     document: args.document,
     changes: args.changes
   });
+  assertStagedUnorderedContainmentValid(args.document, projected, args.changes);
   assertStagedSchemaIdentifiersValid(projected, args.changes);
   assertStagedActionListenersValid(projected, args.changes);
   assertStagedVariantMemberValuesValid(projected, args.changes);
@@ -97811,6 +99108,65 @@ function assertProjectVersionWholeGraphWritesValid(args) {
     });
   }
 }
+function assertStagedUnorderedContainmentValid(current, projected, changes) {
+  const currentValues = new Map(
+    current.values.map((value) => [value.id, value])
+  );
+  const projectedValues = new Map(
+    projected.values.map((value) => [value.id, value])
+  );
+  const projectedMemberByContainerId = /* @__PURE__ */ new Map();
+  for (const value of projected.values) {
+    if (typeof value.containerId !== "string") continue;
+    if (!projectedMemberByContainerId.has(value.containerId)) {
+      projectedMemberByContainerId.set(value.containerId, value);
+    }
+  }
+  for (const change of changes) {
+    if (change.recordKind !== "value") continue;
+    const before = currentValues.get(change.recordId);
+    const after = projectedValues.get(change.recordId);
+    const beforeContainerId = typeof before?.containerId === "string" ? before.containerId : null;
+    const afterContainerId = typeof after?.containerId === "string" ? after.containerId : null;
+    if (before !== void 0 && after !== void 0 && beforeContainerId !== afterContainerId) {
+      throw new Error(
+        `Value "${change.recordId}" cannot change containerId from ${beforeContainerId === null ? "unset" : `"${beforeContainerId}"`} to ${afterContainerId === null ? "unset" : `"${afterContainerId}"`}: unordered-list membership is stamped at creation and immutable (move = delete + recreate).`
+      );
+    }
+    if (before === void 0 && afterContainerId !== null) {
+      if (afterContainerId === change.recordId) {
+        throw new Error(
+          `Value "${change.recordId}" cannot declare itself as its own containerId.`
+        );
+      }
+      const container = projectedValues.get(afterContainerId);
+      if (container === void 0) {
+        throw new Error(
+          `Value "${change.recordId}" joins container "${afterContainerId}", but no live value with that id exists in the projected transaction.`
+        );
+      }
+      if (container.value === null) {
+        throw new Error(
+          `Value "${change.recordId}" joins container "${afterContainerId}", but that list is null \u2014 set the list to [] (a fresh instance) before adding entries.`
+        );
+      }
+      if (!Array.isArray(container.value) || container.value.length > 0) {
+        throw new Error(
+          `Value "${change.recordId}" joins container "${afterContainerId}", but that value does not look like an unordered list container (expected value [] \u2014 got ${Array.isArray(container.value) ? "a non-empty array (ordered list)" : typeof container.value}).`
+        );
+      }
+    }
+    const becameNull = before !== void 0 && after !== void 0 && Array.isArray(before.value) && before.value.length === 0 && after.value === null;
+    if (after === void 0 || becameNull) {
+      const stranded = projectedMemberByContainerId.get(change.recordId);
+      if (stranded !== void 0) {
+        throw new Error(
+          `Value "${change.recordId}" cannot be ${after === void 0 ? "deleted" : "set to null"} while member "${stranded.id}" is still live: cascade-delete the unordered list's members first.`
+        );
+      }
+    }
+  }
+}
 function assertNoValueDematerialization(args) {
   const updates = args.changes.filter(
     (change) => change.recordKind === "value" && change.operation === "update" && change.deleted !== true
@@ -97861,7 +99217,7 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
     return document;
   }
   const rootKinds = /* @__PURE__ */ new Map();
-  const owners = resolveOwnerMembersForValues(
+  const owners = resolveSemanticOwnerMembersForValues(
     document,
     new Set(initializers.map((value) => value.id)),
     void 0,
@@ -97960,16 +99316,45 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
       }
       return member;
     });
+    const constructorGraph = new MaterializedValueGraphContext(document);
+    const deferredParametersByParentId = /* @__PURE__ */ new Map();
+    for (const [parentId, edges] of constructorGraph.edgesByOwnerValueId) {
+      for (const edge of edges) {
+        if (!deferred.has(edge.targetValueId)) continue;
+        const parameterIds = deferredParametersByParentId.get(parentId) ?? /* @__PURE__ */ new Set();
+        parameterIds.add(edge.parameterId);
+        deferredParametersByParentId.set(parentId, parameterIds);
+      }
+    }
     const parentIds = new Set(
-      [...valuesById.values()].flatMap(
-        (row) => containsDirectValueId(row.value, deferred) ? [row.id] : []
-      )
+      [
+        [...valuesById.values()].flatMap(
+          (row) => containsDirectValueId(row.value, deferred) ? [row.id] : []
+        ),
+        ...deferredParametersByParentId.keys()
+      ].flat()
+    );
+    const parentOwners = resolveSemanticOwnerMembersForValues(
+      document,
+      parentIds
     );
-    const parentOwners = resolveOwnerMembersForValues(document, parentIds);
     for (const id2 of parentIds) {
-      const row = valuesById.get(id2);
+      let row = valuesById.get(id2);
+      if (row === void 0) continue;
       const owner = parentOwners.get(id2);
-      if (row === void 0 || owner === void 0) continue;
+      const deferredParameters = deferredParametersByParentId.get(id2);
+      if (deferredParameters !== void 0 && isLiteralValueContent(row) && row.constructorArgs !== void 0 && row.constructorArgs !== null) {
+        row = {
+          ...row,
+          constructorArgs: Object.fromEntries(
+            Object.entries(row.constructorArgs).filter(
+              ([parameterId]) => !deferredParameters.has(parameterId)
+            )
+          )
+        };
+        valuesById.set(id2, row);
+      }
+      if (owner === void 0) continue;
       if (isMemberListBase(owner) && Array.isArray(row.value)) {
         valuesById.set(id2, {
           ...row,
@@ -98273,7 +99658,10 @@ function assertStagedActionListenersValid(projected, changes) {
     const rowsById = new Map(
       projected.values.map((value) => [value.id, value])
     );
-    const owners = resolveOwnerMembersForValues(projected, candidateRowIds);
+    const owners = resolveSemanticOwnerMembersForValues(
+      projected,
+      candidateRowIds
+    );
     for (const [rowId, owner] of owners) {
       if (owner.kind !== 26 /* NSAction */) continue;
       const row = rowsById.get(rowId);
@@ -98316,8 +99704,9 @@ function candidateActionListenerRowIds(projected, actions) {
   for (const action of actions) {
     if (typeof action.valueId === "string") candidates.add(action.valueId);
   }
-  if (actionSchemaKeys.size === 0) return candidates;
   for (const row of projected.values) {
+    if (storedRowActionListeners(row).length > 0) candidates.add(row.id);
+    if (actionSchemaKeys.size === 0) continue;
     if (!isPlainRecord(row.value)) continue;
     for (const schemaKey of actionSchemaKeys) {
       const childId = row.value[schemaKey];
@@ -98542,7 +99931,10 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
     const rowsById = new Map(
       projected.values.map((value) => [value.id, value])
     );
-    const owners = resolveOwnerMembersForValues(projected, candidateRowIds);
+    const owners = resolveSemanticOwnerMembersForValues(
+      projected,
+      candidateRowIds
+    );
     for (const [rowId, owner] of owners) {
       if (owner.kind !== 27 /* Variant */) continue;
       const row = rowsById.get(rowId);
@@ -98744,8 +100136,11 @@ function candidateVariantRowIds(projected, variantMembers) {
   for (const member of variantMembers) {
     if (typeof member.valueId === "string") candidates.add(member.valueId);
   }
-  if (schemaKeys.size === 0) return candidates;
   for (const row of projected.values) {
+    if (row.value === null || isVariantRefValue(row.value)) {
+      candidates.add(row.id);
+    }
+    if (schemaKeys.size === 0) continue;
     if (!isPlainRecord(row.value)) continue;
     for (const schemaKey of schemaKeys) {
       const childId = row.value[schemaKey];
@@ -98780,7 +100175,7 @@ var init_project_version_whole_graph_validation = __esm({
     init_generics();
     init_inheritance();
     init_neoscript();
-    init_value_row_owner_members();
+    init_constructor_argument_ownership();
     init_init_backed_value_materialization();
     init_world_system_classes();
     init_project_world_reference_graph();
@@ -100827,8 +102222,10 @@ function compareInitializerMaterialization(expected, received) {
   const normalizedReceived = normalize(received);
   if (canonicalStringify(normalizedExpected) !== canonicalStringify(normalizedReceived)) {
     const difference = firstDifference(normalizedExpected, normalizedReceived);
+    const rootIndex = difference === null ? null : /^\$\.roots\[(\d+)\]/u.exec(difference.path)?.[1];
+    const sourceValueId = rootIndex === null || rootIndex === void 0 ? void 0 : normalizedExpected.roots[Number(rootIndex)]?.sourceValueId;
     throw new ProjectSourceCommitVerificationError(
-      `Source commit initializer materialization does not match trusted evaluation${difference === null ? "." : ` at ${difference.path}: trusted ${formatDifferenceValue(difference.trusted)}, submitted ${formatDifferenceValue(difference.submitted)}.`}`
+      `Source commit initializer materialization does not match trusted evaluation${difference === null ? "." : `${sourceValueId === void 0 ? "" : ` for root ${JSON.stringify(sourceValueId)}`} at ${difference.path}: trusted ${formatDifferenceValue(difference.trusted)}, submitted ${formatDifferenceValue(difference.submitted)}.`}`
     );
   }
 }
@@ -101242,7 +102639,7 @@ function replayStoredConstructionV4(args) {
     // Instance calls are self-contained. Declaration calls inherit the class
     // header parameters that are in lexical scope at their source site.
     initializerOwnerClass: args.initializerOwnerClass ?? null,
-    lexicalThisClass: initializerReferencesLexicalThis(args.code) ? args.lexicalThisClass ?? null : null,
+    lexicalThisClass: args.lexicalThisClass ?? null,
     storedConstructionReplay: true,
     ...compilationProject === void 0 ? {} : { compilationProject }
   });
@@ -101441,20 +102838,6 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
       throw error;
     }
   }
-  for (const site of valueInitializerCompilationSites(document).values()) {
-    if (isInitValueContent(site.row) && site.row.init.compiled !== void 0) {
-      continue;
-    }
-    compileValueRowInitializerBody({
-      ...compileArgs,
-      member: site.member,
-      valueRow: site.row,
-      valueId: String(Reflect.get(site.row, "id")),
-      initializerOwnerClass: site.ownerClass,
-      lexicalThisClass: site.lexicalThisClass,
-      storedConstructionReplay: true
-    });
-  }
 }
 function assertPulledConstructorsCompiled(document) {
   const uncompiled = (document.constructors ?? []).find(
@@ -101682,6 +103065,14 @@ function buildValueEmitContext(records2, manifest) {
     mainLocale: projectMainLocale(records2),
     symbolsByValueId,
     rootPathsByValueId: rootValuePathsByValueId(records2.values()),
+    collectionBindingValueIds: /* @__PURE__ */ new Set([
+      ...manifest.members.flatMap(
+        (member) => member.kind === "lookup" && typeof member.collectionValueId === "string" ? [member.collectionValueId] : []
+      ),
+      ...(manifest.variantFolders ?? []).flatMap(
+        (folder) => folder.binding === null ? [] : [folder.binding.collectionValueId]
+      )
+    ]),
     variantPathsById: buildVariantPathsByIdV4(manifest),
     symbolsByDialogueId: new Map(
       [...dialogues].flatMap(
@@ -101923,7 +103314,7 @@ function emitStoredConstructorExpression(context, member, valueId, visited = /*
       `Stored construction ${valueId} belongs to a non-Class member.`
     );
   }
-  const classId = stringOrNull(value.classId) ?? stringField3(resolvedMember, "classId");
+  const classId = stringOrNull2(value.classId) ?? stringField3(resolvedMember, "classId");
   const schemaClass2 = context.classes.get(classId);
   if (schemaClass2 === void 0) {
     throw new Error(`Unknown value class ${classId}.`);
@@ -102133,6 +103524,7 @@ function createValueLowerRegistryV4(options = {}) {
   return {
     materializedConstructorExpressions: options.materializedConstructorExpressions ?? /* @__PURE__ */ new Map(),
     pendingValues: /* @__PURE__ */ new Map(),
+    pendingContainerChildCounts: /* @__PURE__ */ new Map(),
     pendingLocalizedTexts: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: /* @__PURE__ */ new Map(),
     referenceObligations: [],
@@ -102199,6 +103591,10 @@ function buildValueLowerContext(state, manifest, options = {}) {
     manifest.classes,
     manifest.constructors
   );
+  const stateRecords = Object.values(state);
+  let storedValuePlacements;
+  const readStoredValuePlacements = () => storedValuePlacements ??= buildStoredValuePlacementIndexV4(stateRecords);
+  let rootValueTargets;
   return {
     state,
     members,
@@ -102218,7 +103614,21 @@ function buildValueLowerContext(state, manifest, options = {}) {
       ])
     ),
     staticValueIdsBySymbol: staticTargets,
-    rootValueTargetsByPath: rootValueTargetsByPath(Object.values(state)),
+    get rootValueTargetsByPath() {
+      return rootValueTargets ??= rootValueTargetsByPath(
+        stateRecords,
+        readStoredValuePlacements()
+      );
+    },
+    readStoredValuePlacements,
+    collectionBindingMemberIds: /* @__PURE__ */ new Set([
+      ...manifest.members.flatMap(
+        (member) => member.kind === "lookup" ? [member.collectionMemberId] : []
+      ),
+      ...(manifest.variantFolders ?? []).flatMap(
+        (folder) => folder.binding === null ? [] : [folder.binding.collectionMemberId]
+      )
+    ]),
     variantPathTargets,
     dialogueTargetsBySymbol: dialogueTargetsBySymbol(options.analysis),
     projectFileIdsBySymbol: projectFileIdsBySymbol(state, options.analysis),
@@ -102229,6 +103639,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     reconstructed: /* @__PURE__ */ new Map(),
     retainedReconstructedKeys: /* @__PURE__ */ new Set(),
     pendingValues: registry.pendingValues,
+    pendingContainerChildCounts: registry.pendingContainerChildCounts,
     pendingLocalizedTexts: registry.pendingLocalizedTexts,
     loweredMemberIdByValueId: /* @__PURE__ */ new Map(),
     storedClassSchemaMemberIds: /* @__PURE__ */ new Map(),
@@ -102507,6 +103918,7 @@ function variantConstructionExpression(binding) {
   return expression;
 }
 function indexStructuralStoredIds(context, rootValueId, rootPath) {
+  const placements = context.readStoredValuePlacements();
   const visit = (valueId, path, depth) => {
     if (depth > 64) return;
     const data = context.state[`value:${valueId}`]?.data;
@@ -102532,26 +103944,12 @@ function indexStructuralStoredIds(context, rootValueId, rootPath) {
         visit(child, childPath, depth + 1);
       }
     }
-    const constructorArgs = data.constructorArgs;
-    const classId = data.classId;
-    const instanceConstructorId = data.instanceConstructorId;
-    if (isObjectRecord2(constructorArgs) && typeof classId === "string" && typeof instanceConstructorId === "string") {
-      const schemaClass2 = context.classes.get(classId);
-      const requiredId = schemaClass2?.requiredConstructorId;
-      const constructor2 = requiredId === void 0 ? void 0 : context.manifestConstructors.get(requiredId);
-      if (schemaClass2 !== void 0 && constructor2 !== void 0) {
-        const settledBy = structuralMemberByParameterName(context, schemaClass2);
-        constructor2.arguments.forEach((parameter4, index) => {
-          const schemaKey = settledBy.get(parameter4.name) ?? settledParameterSchemaKey(context, classId, parameter4.name);
-          const child = constructorArgs[`__arg_${index}__`];
-          if (schemaKey === void 0 || indexedSchemaKeys.has(schemaKey) || typeof child !== "string" || context.state[`value:${child}`] === void 0) {
-            return;
-          }
-          const childPath = `${path}.${schemaKey}`;
-          context.structuralStoredIds.set(childPath, child);
-          visit(child, childPath, depth + 1);
-        });
-      }
+    for (const edge of placements.childrenByParentValueId.get(valueId)?.values() ?? []) {
+      if (edge.source !== "constructor") continue;
+      if (indexedSchemaKeys.has(edge.schemaKey)) continue;
+      const childPath = `${path}.${edge.schemaKey}`;
+      context.structuralStoredIds.set(childPath, edge.childValueId);
+      visit(edge.childValueId, childPath, depth + 1);
     }
   };
   visit(rootValueId, rootPath, 0);
@@ -102856,7 +104254,7 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
       if (storedDefault !== null && canonicallyEqual(seed.value, storedDefault.value) && (seed.classId ?? null) === (typeof storedDefaultClassId === "string" ? storedDefaultClassId : null) && (seed.values === void 0 || seed.values.length === 0) && (seed.bindingMembers === void 0 || seed.bindingMembers.length === 0) && (seed.localizedTexts === void 0 || seed.localizedTexts.length === 0)) {
         for (const id2 of context.pendingValues.keys()) {
           if (!pendingValueIdsBeforeSeed.has(id2)) {
-            context.pendingValues.delete(id2);
+            deletePendingValue(context, id2);
           }
         }
         memberDefaultValues.set(memberId, {
@@ -103356,7 +104754,7 @@ function classGenericEnvironment(context, classId) {
 }
 function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
   const baseDefault = isObjectRecord2(baseData3.defaultValue) ? baseData3.defaultValue : {};
-  const storedClassId = stringOrNull(baseDefault.classId);
+  const storedClassId = stringOrNull2(baseDefault.classId);
   const expression = annotatedValue(
     parseCachedInitializer(context.parsedInitializers, binding.initializer)
   ).expression;
@@ -103614,7 +105012,7 @@ function lowerStoredBinding(context, binding, memberValueIds, seeds) {
       );
       seeds.set(binding.memberId, {
         value: root.value,
-        classId: stringOrNull(root.classId),
+        classId: stringOrNull2(root.classId),
         valueId,
         values: [...existingRows, ...pendingRows],
         ...bindingMembers.length === 0 ? {} : { bindingMembers },
@@ -103734,13 +105132,13 @@ function storedClassSchemaMemberIds(context, classId) {
         }
       }
     }
-    current = stringOrNull(data.extendsClassId);
+    current = stringOrNull2(data.extendsClassId);
   }
   context.storedClassSchemaMemberIds.set(classId, memberIds);
   return memberIds;
 }
 function staticValueSeedRow(value, loweredMemberId) {
-  const id2 = stringOrNull(value.id);
+  const id2 = stringOrNull2(value.id);
   if (id2 === null) throw new Error("Authored value row is missing id.");
   if (loweredMemberId === void 0) {
     throw new Error(`Authored value row ${id2} is missing memberId.`);
@@ -103765,7 +105163,7 @@ function staticValueSeedRow(value, loweredMemberId) {
   return {
     ...fields,
     value: value.value,
-    classId: stringOrNull(value.classId),
+    classId: stringOrNull2(value.classId),
     // A seed row IS the row the push will materialize, and its consumer
     // (`staticValueSeedEmitRecords`) projects provenance straight back out
     // with `pickInstanceProvenance`. Dropping it here left a constructed row
@@ -104047,8 +105445,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
           leaf,
           localizedTexts
         });
-        rows.delete(childId);
-        context.pendingValues.delete(childId);
+        deleteSeedRow(context, rows, childId);
       }
     }
     for (const assignment of expression.initializer ?? []) {
@@ -104086,8 +105483,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         localizedTexts,
         environment
       })) {
-        rows.delete(childId);
-        context.pendingValues.delete(childId);
+        deleteSeedRow(context, rows, childId);
         continue;
       }
       body[assignment.name] = childId;
@@ -104206,6 +105602,27 @@ function registerSeedRow(context, rows, row, source, expression) {
   }
   rows.set(row.id, row);
   context.pendingValues.set(row.id, row);
+  if (row.containerId !== void 0) {
+    context.pendingContainerChildCounts.set(
+      row.containerId,
+      (context.pendingContainerChildCounts.get(row.containerId) ?? 0) + 1
+    );
+  }
+}
+function deleteSeedRow(context, rows, valueId) {
+  rows.delete(valueId);
+  deletePendingValue(context, valueId);
+}
+function deletePendingValue(context, valueId) {
+  const row = context.pendingValues.get(valueId);
+  context.pendingValues.delete(valueId);
+  if (row?.containerId === void 0) return;
+  const remaining = (context.pendingContainerChildCounts.get(row.containerId) ?? 1) - 1;
+  if (remaining === 0) {
+    context.pendingContainerChildCounts.delete(row.containerId);
+  } else {
+    context.pendingContainerChildCounts.set(row.containerId, remaining);
+  }
 }
 function storedSchemaEntries(context, schemaClass2) {
   const entries = /* @__PURE__ */ new Map();
@@ -104332,8 +105749,7 @@ function lowerStructuralConstructionRow(context, member, expression, source, val
         localizedTexts
       });
       constructorArgs[`__arg_${parameterIndex}__`] = inline;
-      rows.delete(childId);
-      context.pendingValues.delete(childId);
+      deleteSeedRow(context, rows, childId);
     }
   });
   for (const assignment of expression.initializer ?? []) {
@@ -104362,8 +105778,7 @@ function lowerStructuralConstructionRow(context, member, expression, source, val
       localizedTexts,
       environment
     })) {
-      rows.delete(childId);
-      context.pendingValues.delete(childId);
+      deleteSeedRow(context, rows, childId);
       continue;
     }
     value[assignment.name] = childId;
@@ -104519,7 +105934,7 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
       return expectedValueId;
     }
     const materializedClass = resolvedMember.kind === "class" && isObjectRecord2(base.value);
-    const effectiveClassId = resolvedMember.kind === "class" ? stringOrNull(base.classId) ?? resolvedMember.classId : null;
+    const effectiveClassId = resolvedMember.kind === "class" ? stringOrNull2(base.classId) ?? resolvedMember.classId : null;
     const materializedPlainClass = materializedClass && effectiveClassId !== null && context.classes.get(effectiveClassId)?.requiredConstructorId === void 0;
     const requiresCanonicalConstruction = storedConstructorArgs === null && materializedClass && !materializedPlainClass;
     const canonicalConstruction = requiresCanonicalConstruction ? context.materializedConstructorExpressions.get(expectedValueId) : void 0;
@@ -104731,7 +106146,7 @@ function authoredResetSchemaKeys(context, base, expression, partial) {
 function lowerClassValue(context, member, expression, base, source, outerEnvironment, authoredSlice, materializedConstruction = "lower") {
   if (expression.kind !== "new")
     throw new Error("Class values require new(...).");
-  const currentClassId = stringOrNull(base.classId) ?? member.classId;
+  const currentClassId = stringOrNull2(base.classId) ?? member.classId;
   const classId = constructedClass(
     context,
     member,
@@ -104875,8 +106290,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
       const constructor2 = storedValueConstructor(
         context,
         schemaClass2,
-        base.constructorArgs,
-        typeof base.instanceConstructorId === "string" ? base.instanceConstructorId : void 0
+        recordedStoredConstructorId(base, schemaClass2)
       );
       const authoredArguments = constructorArgumentExpressions(expression);
       for (let index = 0; index < constructor2.arguments.length; index += 1) {
@@ -104990,7 +106404,7 @@ function retainStoredValueSubgraph(context, valueId, source, visited, member) {
     for (const entry of Object.values(value)) collect(entry, childMember);
   };
   const body = state.data.value;
-  const storedClassId = stringOrNull(state.data.classId);
+  const storedClassId = stringOrNull2(state.data.classId);
   if (isObjectRecord2(body) && storedClassId !== null) {
     const storedMemberIds = storedClassSchemaMemberIds(context, storedClassId);
     for (const [schemaKey, child] of Object.entries(body)) {
@@ -105544,7 +106958,7 @@ function lowerListValue(context, member, expression, base, source, inheritedEnvi
           element,
           source,
           `${String(base.id)}[${index}]`,
-          member.listKind === "unordered" ? stringOrNull(base.id) : void 0,
+          member.listKind === "unordered" ? stringOrNull2(base.id) : void 0,
           environment,
           entrySlices[index]
         )
@@ -105566,7 +106980,7 @@ function lowerListValue(context, member, expression, base, source, inheritedEnvi
           element,
           source,
           `${String(base.id)}[${index}]`,
-          member.listKind === "unordered" ? stringOrNull(base.id) : void 0,
+          member.listKind === "unordered" ? stringOrNull2(base.id) : void 0,
           environment,
           entrySlices[index]
         )
@@ -105622,7 +107036,7 @@ function lowerPendingListItem(context, member, expression, source, path, contain
 }
 function existingListItemIds(context, member, base) {
   if (member.listKind === "unordered") {
-    const containerId = stringOrNull(base.id);
+    const containerId = stringOrNull2(base.id);
     if (containerId === null) return /* @__PURE__ */ new Set();
     return context.valuePlacements.valueIdsByContainerId.get(containerId) ?? /* @__PURE__ */ new Set();
   }
@@ -106574,6 +107988,7 @@ function freshChildReplaysDeclaredDefault(args) {
   if (child.genericBindings !== void 0) return false;
   if (child.instanceVariantId != null) return false;
   if (child.instanceVariantRowValueId != null) return false;
+  if (context.collectionBindingMemberIds.has(childMember.id)) return false;
   const defaultValue = childMember.defaultValue;
   if (defaultValue === null || defaultValue === void 0) return false;
   if (!("value" in defaultValue)) return false;
@@ -106592,7 +108007,12 @@ function freshChildReplaysDeclaredDefault(args) {
       defaultValue
     );
   }
-  if (resolved.kind === "list" || resolved.kind === "dictionary") return false;
+  if (resolved.kind === "list") {
+    return Array.isArray(child.value) && child.value.length === 0 && !context.pendingContainerChildCounts.has(childId) && Array.isArray(defaultValue.value) && defaultValue.value.length === 0 && child.classId == null && child.constructorArgs === void 0 && child.instanceConstructorId == null;
+  }
+  if (resolved.kind === "dictionary") {
+    return isObjectRecord2(child.value) && Object.keys(child.value).length === 0 && isObjectRecord2(defaultValue.value) && Object.keys(defaultValue.value).length === 0 && child.classId == null && child.constructorArgs === void 0 && child.instanceConstructorId == null;
+  }
   if (resolved.kind === "string" && resolved.localizable === true) return false;
   if (child.classId !== null && child.classId !== void 0) return false;
   if (isObjectRecord2(child.constructorArgs)) return false;
@@ -106987,7 +108407,7 @@ function emitValueBody(context, member, value, visited, targetTyped, environment
 function classValue(context, member, value, visited, targetTyped, outerEnvironment) {
   if (value.value === null) return "null";
   const partial = member.partial === true;
-  const classId = stringOrNull(value.classId) ?? stringField3(member, "classId");
+  const classId = stringOrNull2(value.classId) ?? stringField3(member, "classId");
   const schemaClass2 = context.classes.get(classId);
   if (schemaClass2 === void 0)
     throw new Error(`Unknown value class ${classId}.`);
@@ -107100,11 +108520,12 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     const childMember = context.members.get(childMemberId);
     if (childMember === void 0)
       throw new Error(`Class ${name}.${key} has no member record.`);
-    if (emitsAsMemberDefaultDerivedAbsence(context, childMember, childId)) {
+    const preservesExternalBinding = context.collectionBindingValueIds.has(childId);
+    if (!preservesExternalBinding && emitsAsMemberDefaultDerivedAbsence(context, childMember, childId)) {
       continue;
     }
     const replayChildId = replayBody[key];
-    if (replayGraph !== null && typeof replayChildId === "string" && materializedValueSubgraphsEqual(
+    if (!preservesExternalBinding && replayGraph !== null && typeof replayChildId === "string" && materializedValueSubgraphsEqual(
       context,
       context.readMaterializedGraph(),
       replayGraph,
@@ -107151,7 +108572,7 @@ function emitsAsMemberDefaultDerivedAbsence(context, member, valueId) {
   const body = value.value;
   if (!isObjectRecord2(body)) return false;
   if (Object.keys(body).length > 0) return false;
-  const effectiveClassId = stringOrNull(value.classId) ?? stringOrNull(member.classId);
+  const effectiveClassId = stringOrNull2(value.classId) ?? stringOrNull2(member.classId);
   if (effectiveClassId === null) return false;
   return derivesContentFromMemberDefault({
     member,
@@ -107275,18 +108696,21 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
     }
     return targetTyped ? "new()" : `new ${className}()`;
   }
+  const recordedConstructorId = recordedStoredConstructorId(
+    value,
+    manifestClass
+  );
   const constructor2 = storedValueConstructor(
     context,
     manifestClass,
-    constructorArgs,
-    typeof value.instanceConstructorId === "string" ? value.instanceConstructorId : void 0
+    recordedConstructorId
   );
   const argumentsValue = constructor2.arguments.flatMap((argument2, index) => {
     const key = `__arg_${index}__`;
     if (!(key in constructorArgs)) {
       if (argument2.default !== null || argument2.type.nullable) return [];
       throw new Error(
-        `Stored construction on value row "${stringOrNull(value.id) ?? "<unknown>"}" of class "${stringOrNull(schemaClass2.name) ?? "<unnamed>"}" (${stringOrNull(schemaClass2.id) ?? "<no id>"}) is missing evaluated argument ${key} for required parameter "${argument2.name}".`
+        `Stored construction on value row "${stringOrNull2(value.id) ?? "<unknown>"}" of class "${stringOrNull2(schemaClass2.name) ?? "<unnamed>"}" (${stringOrNull2(schemaClass2.id) ?? "<no id>"}) is missing evaluated argument ${key} for required parameter "${argument2.name}".`
       );
     }
     const settledMember = settledMemberForConstructorArgument(
@@ -107373,47 +108797,27 @@ function constructorCallSource(callee, argumentsValue) {
 ${argumentsValue.map((argument2) => `${indentNeoSourceNonEmptyLines(argument2, 2)},`).join("\n")}
 )`;
 }
-function storedValueConstructor(context, schemaClass2, constructorArgs, recordedConstructorId) {
-  if (recordedConstructorId !== void 0) {
-    const recorded = context.manifestConstructors.get(recordedConstructorId);
-    if (recorded === void 0) {
-      throw new Error(
-        `Stored construction for ${schemaClass2.name} names missing constructor ${recordedConstructorId}.`
-      );
-    }
-    if (schemaClass2.requiredConstructorId !== recordedConstructorId && !(schemaClass2.constructorIds ?? []).includes(recordedConstructorId)) {
-      throw new Error(
-        `Stored construction for ${schemaClass2.name} names constructor ${recordedConstructorId}, which the class does not declare.`
-      );
-    }
-    return recorded;
-  }
-  const requiredId = schemaClass2.requiredConstructorId;
-  if (requiredId !== void 0) {
-    const required2 = context.manifestConstructors.get(requiredId);
-    if (required2 === void 0) {
-      throw new Error(
-        `Stored construction for ${schemaClass2.name} names missing required constructor ${requiredId}.`
-      );
-    }
-    return required2;
+function storedValueConstructor(context, schemaClass2, recordedConstructorId) {
+  const recorded = context.manifestConstructors.get(recordedConstructorId);
+  if (recorded === void 0) {
+    throw new Error(
+      `Stored construction for ${schemaClass2.name} names missing constructor ${recordedConstructorId}.`
+    );
   }
-  const count = Object.keys(constructorArgs).length;
-  const candidates = (schemaClass2.constructorIds ?? []).map((id2) => context.manifestConstructors.get(id2)).filter(
-    (candidate) => candidate !== void 0 && candidate.arguments.length === count
-  );
-  if (candidates.length !== 1) {
+  if (schemaClass2.requiredConstructorId !== recordedConstructorId && !(schemaClass2.constructorIds ?? []).includes(recordedConstructorId)) {
     throw new Error(
-      `Stored construction for ${schemaClass2.name} cannot select one constructor from ${candidates.length} ${count}-argument candidates.`
+      `Stored construction for ${schemaClass2.name} names constructor ${recordedConstructorId}, which the class does not declare.`
     );
   }
-  const selected = candidates[0];
-  if (selected === void 0) {
+  return recorded;
+}
+function recordedStoredConstructorId(value, schemaClass2) {
+  if (typeof value.instanceConstructorId !== "string") {
     throw new Error(
-      `Stored construction for ${schemaClass2.name} resolved no constructor.`
+      `Stored construction on value row "${stringOrNull2(value.id) ?? "<unknown>"}" of class "${schemaClass2.name}" (${schemaClass2.id}) is not canonical: constructorArgs requires a recorded instanceConstructorId.`
     );
   }
-  return selected;
+  return value.instanceConstructorId;
 }
 function storedConstructorArgumentSource(context, type, value, environment, visited, cloneAggregateArguments = false, partial = false, constructorOwnsGraph = false) {
   if (value === null) {
@@ -108656,7 +110060,7 @@ function stringField3(value, key) {
   if (typeof result !== "string") throw new Error(`Expected string ${key}.`);
   return result;
 }
-function stringOrNull(value) {
+function stringOrNull2(value) {
   return typeof value === "string" ? value : null;
 }
 function numberOr2(value, fallback) {
@@ -108688,6 +110092,7 @@ var init_value_sources = __esm({
     init_init_source();
     init_source_format();
     init_root_value_paths();
+    init_stored_value_placements();
     init_world_system_classes();
     init_member_value_id();
     init_instance_provenance();
@@ -112647,7 +114052,10 @@ var init_history = __esm({
 function auditProjectIntegrity(workspace) {
   const records2 = workspace.state.records;
   const values = collectValueRows(records2);
-  const placements = collectPlacements(values);
+  const storedPlacements = buildStoredValuePlacementIndexV4(
+    Object.values(records2)
+  );
+  const placements = collectPlacements(values, storedPlacements);
   const memberIdBySchemaKey = collectClassSchemas(records2);
   const storageKeyByMemberId = collectMemberStorageKeys(records2);
   const findings = [];
@@ -112871,7 +114279,7 @@ function collectValueRows(records2) {
   }
   return values;
 }
-function collectPlacements(values) {
+function collectPlacements(values, storedPlacements) {
   const placements = /* @__PURE__ */ new Map();
   const claim = (childId, placement) => {
     if (values.has(childId) && !placements.has(childId)) {
@@ -112899,6 +114307,12 @@ function collectPlacements(values) {
     if (container === void 0) continue;
     claim(value.id, { parent: container, schemaKey: UNORDERED_MEMBERSHIP_KEY });
   }
+  for (const edge of storedPlacements.placementByChildValueId.values()) {
+    if (edge.source !== "constructor") continue;
+    const parent = values.get(edge.parentValueId);
+    if (parent === void 0) continue;
+    claim(edge.childValueId, { parent, schemaKey: edge.schemaKey });
+  }
   return placements;
 }
 function collectClassSchemas(records2) {
@@ -112971,6 +114385,7 @@ var init_project_integrity = __esm({
     init_member_storage_key();
     init_system_record_id();
     init_projection();
+    init_stored_value_placements();
     UNORDERED_MEMBERSHIP_KEY = "(container)";
     MEMBER_KIND_STRING = 3;
     RECORD_ID_PATTERN2 = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
@@ -118971,7 +120386,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.38.1",
+      cliVersion: "0.38.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120316,7 +121731,7 @@ import {
   sep as sep5
 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function expectation(actual, negated = false) {
@@ -120327,13 +121742,13 @@ function expectation(actual, negated = false) {
   return value;
 }
 function readExpectation(value) {
-  if (!isRecord9(value) || value.__neoExpectation !== true) {
+  if (!isRecord10(value) || value.__neoExpectation !== true) {
     throw new NeoTestAssertionError("Matcher receiver is not an expectation.");
   }
   return value;
 }
 function readMockHandle(value) {
-  if (!isRecord9(value) || value.__neoMockHandle !== true || typeof value.mockId !== "number") {
+  if (!isRecord10(value) || value.__neoMockHandle !== true || typeof value.mockId !== "number") {
     throw new NeoTestAssertionError(
       "Mock configuration receiver is not a mock handle."
     );
@@ -120444,13 +121859,13 @@ function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function findDelegateTargetMemberId(value) {
-  return isRecord9(value) && typeof value.memberId === "string" ? value.memberId : null;
+  return isRecord10(value) && typeof value.memberId === "string" ? value.memberId : null;
 }
 function sharedEvaluatorBase(rawDocument) {
   const cached = SHARED_EVALUATOR_BASES.get(rawDocument);
   if (cached !== void 0) return cached;
   const document = readDocumentArrays(rawDocument);
-  const constructors = Array.isArray(rawDocument.constructors) ? rawDocument.constructors.filter(isRecord9) : [];
+  const constructors = Array.isArray(rawDocument.constructors) ? rawDocument.constructors.filter(isRecord10) : [];
   const lookups = cliEvaluatorLookups(
     { ...document, constructors },
     { includeValueGraphIndexes: true }
@@ -120518,7 +121933,7 @@ function preparedHookCandidate(workspace) {
     const parsed = JSON.parse(
       readFileSync16(join16(directory, "candidate.json"), "utf8")
     );
-    if (!isRecord9(parsed)) {
+    if (!isRecord10(parsed)) {
       throw new NeoTestPreparedCandidateError(
         "Configured push hook candidate manifest must be a JSON object."
       );
@@ -120538,7 +121953,7 @@ function preparedHookCandidate(workspace) {
         "Configured push hook candidate inputs no longer match the workspace."
       );
     }
-    if (!isRecord9(parsed.document)) {
+    if (!isRecord10(parsed.document)) {
       throw new NeoTestPreparedCandidateError(
         "Configured push hook candidate is missing its project document."
       );
@@ -120587,7 +122002,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
   try {
     const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
     const parsed = JSON.parse(readFileSync16(candidatePath, "utf8"));
-    if (!isRecord9(parsed)) return null;
+    if (!isRecord10(parsed)) return null;
     if (parsed.version !== 1) return null;
     if (parsed.candidateRevision !== TEST_CANDIDATE_CACHE_REVISION) return null;
     if (parsed.cliVersion !== PROJECT_SCHEMA_CONTRACT.cliVersion) return null;
@@ -120605,7 +122020,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
       return null;
     }
     const document = JSON.parse(documentJson);
-    if (!isRecord9(document)) return null;
+    if (!isRecord10(document)) return null;
     return {
       document,
       sourceHash: parsed.sourceHash,
@@ -120649,7 +122064,7 @@ function compileSpec(workspace, document, absolutePath, projectCompilationHash2)
   );
   try {
     const cached = JSON.parse(readFileSync16(artifactPath, "utf8"));
-    if (isRecord9(cached) && cached.version === 1 && cached.compilerRevision === NEOSCRIPT_COMPILER_REVISION && cached.projectCompilationHash === projectCompilationHash2 && cached.sourceHash === sourceHash && isRecord9(cached.action) && typeof cached.artifactSha256 === "string" && createHash11("sha256").update(JSON.stringify(cached.action)).digest("hex") === cached.artifactSha256 && cached.action.compilerRevision === NEOSCRIPT_COMPILER_REVISION && Array.isArray(cached.action.parameters) && Array.isArray(cached.action.instructions) && isRecord9(cached.action.typeInfo)) {
+    if (isRecord10(cached) && cached.version === 1 && cached.compilerRevision === NEOSCRIPT_COMPILER_REVISION && cached.projectCompilationHash === projectCompilationHash2 && cached.sourceHash === sourceHash && isRecord10(cached.action) && typeof cached.artifactSha256 === "string" && createHash11("sha256").update(JSON.stringify(cached.action)).digest("hex") === cached.artifactSha256 && cached.action.compilerRevision === NEOSCRIPT_COMPILER_REVISION && Array.isArray(cached.action.parameters) && Array.isArray(cached.action.instructions) && isRecord10(cached.action.typeInfo)) {
       return {
         path,
         source,
@@ -120813,7 +122228,7 @@ function portableDelegate(value) {
   }
 }
 function callMemberId(value) {
-  if (!isRecord9(value) || value.type !== "callFunction") return null;
+  if (!isRecord10(value) || value.type !== "callFunction") return null;
   return typeof value.memberId === "string" ? value.memberId : null;
 }
 function assertNoNestedRegistration(value) {
@@ -120821,7 +122236,7 @@ function assertNoNestedRegistration(value) {
     for (const entry of value) assertNoNestedRegistration(entry);
     return;
   }
-  if (!isRecord9(value)) return;
+  if (!isRecord10(value)) return;
   const memberId = callMemberId(value);
   if (memberId !== null && REGISTRATION_IDS.has(memberId)) {
     throw new NeoTestRegistrationError(
@@ -120837,8 +122252,8 @@ function compiledDelegateActions(value) {
       for (const child of entry) visit(child);
       return;
     }
-    if (!isRecord9(entry)) return;
-    if (isRecord9(entry.action) && Array.isArray(entry.action.instructions) && Array.isArray(entry.action.parameters) && isRecord9(entry.action.typeInfo)) {
+    if (!isRecord10(entry)) return;
+    if (isRecord10(entry.action) && Array.isArray(entry.action.instructions) && Array.isArray(entry.action.parameters) && isRecord10(entry.action.typeInfo)) {
       actions.push(entry.action);
       return;
     }
@@ -120849,7 +122264,7 @@ function compiledDelegateActions(value) {
 }
 function validateRegistrationAction(action, allowRegistration) {
   for (const instruction of action.instructions) {
-    const record3 = isRecord9(instruction) ? instruction : null;
+    const record3 = isRecord10(instruction) ? instruction : null;
     const call = record3?.type === "functionCall" ? record3.call : null;
     const memberId = callMemberId(call);
     if (memberId !== null && REGISTRATION_IDS.has(memberId)) {
@@ -120982,8 +122397,8 @@ function mockResponse(environment, mock, selected, call) {
   };
 }
 function partialObjectMatch(actual, expected) {
-  if (!isRecord9(expected)) return isDeepStrictEqual(actual, expected);
-  if (!isRecord9(actual)) return false;
+  if (!isRecord10(expected)) return isDeepStrictEqual(actual, expected);
+  if (!isRecord10(actual)) return false;
   return Object.entries(expected).every(
     ([key, value]) => partialObjectMatch(actual[key], value)
   );
@@ -121175,7 +122590,7 @@ function interceptTestCallCore(environment, call) {
     const contains2 = typeof actual === "string" ? actual.includes(String(call.args[0])) : Array.isArray(actual) && actual.some((entry) => isDeepStrictEqual(entry, call.args[0]));
     assertMatcher(contains2, expectationValue, "toContain", call.args[0]);
   } else if (call.memberId === NEO_TEST_IDS.toHaveLength) {
-    const length = typeof actual === "string" || Array.isArray(actual) ? actual.length : isRecord9(actual) ? Object.keys(actual).length : -1;
+    const length = typeof actual === "string" || Array.isArray(actual) ? actual.length : isRecord10(actual) ? Object.keys(actual).length : -1;
     assertMatcher(
       length === call.args[0],
       expectationValue,
@@ -121266,11 +122681,11 @@ function snapshotEnvironmentDocument(environment) {
   const values = [...baseValues];
   const byId = /* @__PURE__ */ new Map();
   values.forEach((value, index) => {
-    if (isRecord9(value) && typeof value.id === "string")
+    if (isRecord10(value) && typeof value.id === "string")
       byId.set(value.id, index);
   });
   const mergeRow = (row) => {
-    if (!isRecord9(row) || typeof row.id !== "string") return;
+    if (!isRecord10(row) || typeof row.id !== "string") return;
     const cloned = structuredClone(row);
     const index = byId.get(row.id);
     if (index === void 0) {
@@ -121286,7 +122701,7 @@ function snapshotEnvironmentDocument(environment) {
   if (bindings.size > 0) {
     const baseMembers = Array.isArray(snapshot.members) ? snapshot.members : [];
     snapshot.members = baseMembers.map((member) => {
-      if (!isRecord9(member) || typeof member.id !== "string" || !bindings.has(member.id)) {
+      if (!isRecord10(member) || typeof member.id !== "string" || !bindings.has(member.id)) {
         return member;
       }
       return { ...member, valueId: bindings.get(member.id) ?? null };
@@ -125694,7 +127109,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.38.1");
+    console.log("0.38.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {