@neocompose/cli 0.89.7 → 0.89.9

package/dist/neo-runtime.mjs

@@ -7354,42 +7354,6 @@ function descendantClassIdsInChildIndex(classId, childrenByClassId) {
   }
   return result;
 }
-function addDependentMemberIds(memberIds, members2) {
-  const childIdsByParentId = /* @__PURE__ */ new Map();
-  const entryIdsByOwnerId = /* @__PURE__ */ new Map();
-  const remainingOwnersByEntryId = /* @__PURE__ */ new Map();
-  for (const member of members2) {
-    if (member.extendsMemberId) {
-      const children3 = childIdsByParentId.get(member.extendsMemberId);
-      if (children3 === void 0) {
-        childIdsByParentId.set(member.extendsMemberId, [member.id]);
-      } else children3.push(member.id);
-    }
-    const entries = member.elementMemberIds ?? (member.entryMemberId ? [member.entryMemberId] : []);
-    if (entries.length > 0) {
-      entryIdsByOwnerId.set(member.id, entries);
-      for (const entryId of entries)
-        remainingOwnersByEntryId.set(
-          entryId,
-          (remainingOwnersByEntryId.get(entryId) ?? 0) + 1
-        );
-    }
-  }
-  const pending = [...memberIds];
-  function include(memberId) {
-    if (memberIds.has(memberId)) return;
-    memberIds.add(memberId);
-    pending.push(memberId);
-  }
-  for (let id2 = pending.pop(); id2 !== void 0; id2 = pending.pop()) {
-    for (const childId of childIdsByParentId.get(id2) ?? []) include(childId);
-    for (const entryId of entryIdsByOwnerId.get(id2) ?? []) {
-      const remainingOwners = remainingOwnersByEntryId.get(entryId) - 1;
-      remainingOwnersByEntryId.set(entryId, remainingOwners);
-      if (remainingOwners === 0) include(entryId);
-    }
-  }
-}
 var UnresolvedMemberInheritanceError, NO_CLASSES, NO_MEMBERS, resolvedClassSchemas;
 var init_inheritance = __esm({
   "../packages/models/src/classes/inheritance.ts"() {
@@ -19407,7 +19371,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.89.7",
+      cliVersion: "0.89.9",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -24412,7 +24376,7 @@ function mayUseLocalInitializer(text, names2) {
   }
   return false;
 }
-function localInitializerUses(expression) {
+function localInitializerUses(expression, options = {}) {
   const uses = [];
   const pending = [
     { node: expression, owned: true, path: { parent: void 0, key: "" } }
@@ -24431,7 +24395,12 @@ function localInitializerUses(expression) {
         const keys = [];
         for (let step = path; step?.parent !== void 0; step = step.parent)
           keys.push(step.key);
-        uses.push({ node, owned, path: path === null ? null : keys.reverse() });
+        uses.push({
+          node,
+          owned,
+          path: path === null ? null : keys.reverse(),
+          ...current.reference ? { reference: true } : {}
+        });
         break;
       }
       case "annotated":
@@ -24479,8 +24448,18 @@ function localInitializerUses(expression) {
         }
         break;
       case "call":
-        if (node.callee.kind === "ident" && node.callee.name === "Reference")
+        if (node.callee.kind === "ident" && node.callee.name === "Reference") {
+          if (options.includeReferences && node.args.length === 1 && node.args[0]?.kind === "ident" && node.argumentNames?.[0] == null) {
+            pending.push({
+              node: node.args[0],
+              owned: false,
+              path: null,
+              bound,
+              reference: true
+            });
+          }
           break;
+        }
         add([node.callee, ...node.args], false);
         break;
       case "member":
@@ -24525,10 +24504,10 @@ function applyInitializerCodeSplices(code, splices) {
   parts.push(code.slice(offset));
   return parts.join("");
 }
-function rewriteLocalInitializerUses(code, replace) {
+function rewriteLocalInitializerUses(code, replace, options = {}) {
   const source = new SourceText(code);
   const splices = [];
-  for (const use of localInitializerUses(parseExpression(code))) {
+  for (const use of localInitializerUses(parseExpression(code), options)) {
     const text = replace(use);
     if (text === null) continue;
     const start = source.offsetAt({
@@ -24634,10 +24613,27 @@ function validateExecutableLocalUses(documents, localExpressions) {
     }
   }
   if (locals.size === 0) return [];
-  const aliases = /* @__PURE__ */ new Map();
+  const terminalNames = /* @__PURE__ */ new Map();
+  const terminalName = (name) => {
+    const chain = /* @__PURE__ */ new Set();
+    let terminal2 = name;
+    while (!chain.has(terminal2)) {
+      const cached = terminalNames.get(terminal2);
+      if (cached !== void 0) {
+        terminal2 = cached;
+        break;
+      }
+      chain.add(terminal2);
+      const expression = localExpressions.get(terminal2);
+      if (expression?.kind !== "ident" || !locals.has(expression.name)) break;
+      terminal2 = expression.name;
+    }
+    for (const alias of chain) terminalNames.set(alias, terminal2);
+    return terminal2;
+  };
   const uses = [];
   const owners = /* @__PURE__ */ new Map();
-  const add = (text, uri, origin, parent, staticOwner, template = false, shadowed = /* @__PURE__ */ new Set()) => {
+  const add = (text, uri, origin, parent, template = false, shadowed = /* @__PURE__ */ new Set()) => {
     if (!mayUseLocalInitializer(text, locals)) return;
     let expression;
     try {
@@ -24645,10 +24641,8 @@ function validateExecutableLocalUses(documents, localExpressions) {
     } catch {
       return;
     }
-    if (parent !== void 0) {
-      if (expression.kind === "ident" && locals.has(expression.name))
-        aliases.set(parent, expression.name);
-    }
+    if (parent !== void 0 && expression.kind === "ident" && locals.has(expression.name))
+      return;
     for (const { node, owned } of localInitializerUses(expression)) {
       if (!locals.has(node.name) || shadowed.has(node.name)) continue;
       const start = {
@@ -24661,14 +24655,14 @@ function validateExecutableLocalUses(documents, localExpressions) {
         uri,
         start,
         parent,
-        staticOwner: expression === node ? staticOwner : void 0,
         template
       };
       uses.push(use);
       if (owned) {
-        const entries = owners.get(node.name) ?? [];
+        const terminal2 = terminalName(node.name);
+        const entries = owners.get(terminal2) ?? [];
         entries.push(use);
-        owners.set(node.name, entries);
+        owners.set(terminal2, entries);
       }
     }
   };
@@ -24684,7 +24678,6 @@ function validateExecutableLocalUses(documents, localExpressions) {
             uri,
             member.initializer.range.start,
             void 0,
-            isStatic ? `${declaration.name}.${member.name}` : void 0,
             !isStatic,
             new Set(
               declaration.headerParameters?.map((parameter4) => parameter4.name)
@@ -24721,23 +24714,20 @@ function validateExecutableLocalUses(documents, localExpressions) {
   const placements = /* @__PURE__ */ new Map();
   const active = /* @__PURE__ */ new Set();
   const placement = (name) => {
+    name = terminalName(name);
     const cached = placements.get(name);
     if (cached !== void 0) return cached;
-    if (active.has(name))
-      return { count: 0, template: false, staticOwner: void 0 };
+    if (active.has(name)) return { count: 0, template: false };
     active.add(name);
     const result = {
       count: 0,
-      template: false,
-      staticOwner: void 0
+      template: false
     };
     for (const owner of owners.get(name) ?? []) {
       const parent = owner.parent === void 0 ? void 0 : placement(owner.parent);
       if (parent?.count === 0) continue;
       result.count += parent?.count ?? 1;
       result.template ||= parent?.template ?? owner.template;
-      const alias = owner.parent !== void 0 && aliases.get(owner.parent) === name;
-      result.staticOwner = alias ? parent?.staticOwner : owner.staticOwner;
       if (result.count > 1) break;
     }
     active.delete(name);
@@ -24763,22 +24753,6 @@ function validateExecutableLocalUses(documents, localExpressions) {
       if (declaration.kind === "enum") scalarTypes.add(declaration.name);
     }
   }
-  const identities = /* @__PURE__ */ new Map();
-  const resolving = /* @__PURE__ */ new Set();
-  const hasIdentity = (name) => {
-    const cached = identities.get(name);
-    if (cached !== void 0) return cached;
-    if (resolving.has(name)) return false;
-    resolving.add(name);
-    const alias = aliases.get(name);
-    const expression = localExpressions.get(name);
-    const identified = alias !== void 0 ? hasIdentity(alias) : locals.get(name).annotations.some((annotation2) => annotation2.name === "id") || expression?.kind === "annotated" && expression.annotations.some(
-      (annotation2) => annotation2.name === "id"
-    );
-    resolving.delete(name);
-    identities.set(name, identified);
-    return identified;
-  };
   const reportedOwners = /* @__PURE__ */ new Set();
   for (const use of uses) {
     const declaration = locals.get(use.name);
@@ -24807,13 +24781,6 @@ function validateExecutableLocalUses(documents, localExpressions) {
       );
       continue;
     }
-    const hasId = hasIdentity(use.name);
-    if (!hasId && owner.staticOwner === void 0) {
-      report(
-        use,
-        `Local initializer ${use.name} has no stable instance identity. Keep an @id on its nested owning value, or place it directly in a static member before referencing it.`
-      );
-    }
     if (owner.template) {
       report(
         use,
@@ -25265,6 +25232,7 @@ var init_local_values = __esm({
       /** Static members whose initializer is a bare local name, by that name. */
       ownerMembers = /* @__PURE__ */ new Map();
       scalarTypes;
+      pendingReferences = /* @__PURE__ */ new Map();
       resolve(expression, source, valueId) {
         if (expression.kind !== "ident") return { expression, source };
         let text;
@@ -25331,12 +25299,55 @@ var init_local_values = __esm({
       executable(code, runtimeIdentifiers = /* @__PURE__ */ new Set(), materializationRoot, identity3, storedValueAtPath) {
         if (this.definitions.size === 0 || !mayUseLocalInitializer(code, this.definitions))
           return { code, splices: [] };
+        const terminalName = (name) => {
+          this.inline(name);
+          return this.terminalInitializers.get(name)?.global.name ?? name;
+        };
+        const owned = /* @__PURE__ */ new Set();
+        const read = /* @__PURE__ */ new Set();
+        const scanned = /* @__PURE__ */ new Set();
+        const usedNames = new Set(runtimeIdentifiers);
+        const scan = (text, runtimeNames) => {
+          for (const match of text.matchAll(/[A-Za-z_]\w*/g))
+            usedNames.add(match[0]);
+          for (const use of localInitializerUses(
+            parseCachedInitializer(this.syntax?.expressions, text),
+            { includeReferences: true }
+          )) {
+            if (!this.has(use.node.name) || runtimeNames.has(use.node.name))
+              continue;
+            const name = terminalName(use.node.name);
+            if (!use.owned) {
+              read.add(name);
+              continue;
+            }
+            owned.add(name);
+            if (scanned.has(name)) continue;
+            scanned.add(name);
+            scan(this.inline(name).text, /* @__PURE__ */ new Set());
+          }
+        };
+        scan(code, runtimeIdentifiers);
+        const shared = /* @__PURE__ */ new Map();
+        for (const name of owned) {
+          if (!read.has(name) || this.scalarTypes.has(this.definitions.get(name).type.name))
+            continue;
+          let variable2 = `__neo_owned_${shared.size}`;
+          while (usedNames.has(variable2) || this.definitions.has(variable2) || runtimeIdentifiers.has(variable2))
+            variable2 += "_";
+          usedNames.add(variable2);
+          shared.set(name, variable2);
+        }
+        const bindings = /* @__PURE__ */ new Map();
         const active = /* @__PURE__ */ new Set();
         const expand = (text, path, runtimeNames) => rewriteLocalInitializerUses(
           text,
-          ({ node, owned, path: relativePath }) => {
+          ({ node, owned: owned2, path: relativePath, reference: reference2 }) => {
             if (!this.has(node.name) || runtimeNames.has(node.name)) return null;
-            if (!owned) {
+            if (!owned2) {
+              const variable3 = shared.get(terminalName(node.name));
+              if (variable3 !== void 0) return variable3;
+              if (reference2) return null;
               const definition2 = this.definitions.get(node.name);
               if (this.scalarTypes.has(definition2.type.name)) {
                 throw new Error(
@@ -25362,9 +25373,13 @@ var init_local_values = __esm({
               const annotation2 = terminal2.expression.kind === "annotated" ? terminal2.expression.annotations.find(
                 (entry) => entry.name === "id"
               )?.args[0] : void 0;
-              if (annotation2?.kind === "litString" && storedValueAtPath?.(materializationRoot, placementPath) !== annotation2.value) {
+              const existingId = storedValueAtPath?.(
+                materializationRoot,
+                placementPath
+              );
+              if (annotation2?.kind === "litString" && existingId !== annotation2.value) {
                 throw new Error(
-                  `Local initializer ${terminal2.global.name} has an @id that does not identify its existing row inside this constructor-backed owner. Remove that @id and push its owning tree before referencing the local, or place the value directly in its own static member.`
+                  `Local initializer ${terminal2.global.name} has an @id that does not identify its existing row inside this constructor-backed owner. Remove that @id and let preparation assign the owning tree, or place the value directly in its own static member.`
                 );
               }
               const source = terminal2.global.source;
@@ -25372,7 +25387,7 @@ var init_local_values = __esm({
               const id2 = annotation2?.kind === "litString" ? annotation2.value : `__pending__:value:${encodeURIComponent(source.uri)}:${source.range.start.line}:${source.range.start.character}:${encodeURIComponent(terminal2.global.name)}${suffix}`;
               for (const { global } of steps) {
                 const owners = this.owners.get(global.name) ?? /* @__PURE__ */ new Map();
-                owners.set(id2, global.name);
+                owners.set(existingId ?? id2, global.name);
                 this.owners.set(global.name, owners);
               }
               identity3?.sites.set(id2, {
@@ -25391,10 +25406,50 @@ var init_local_values = __esm({
               });
             }
             active.delete(node.name);
+            const name = terminalName(node.name);
+            const variable2 = shared.get(name);
+            if (variable2 !== void 0) {
+              bindings.set(variable2, {
+                code: result,
+                type: typeText(this.definitions.get(name).type)
+              });
+              return variable2;
+            }
             return result;
-          }
+          },
+          { includeReferences: true }
         );
-        return expand(code, [], runtimeIdentifiers);
+        const expanded = expand(code, [], runtimeIdentifiers);
+        if (bindings.size === 0) return expanded;
+        const ordered = [];
+        const visited = /* @__PURE__ */ new Set();
+        const visit = (variable2) => {
+          if (visited.has(variable2)) return;
+          visited.add(variable2);
+          for (const use of localInitializerUses(
+            parseCachedInitializer(
+              this.syntax?.expressions,
+              bindings.get(variable2).code
+            ),
+            { includeReferences: true }
+          )) {
+            if (bindings.has(use.node.name)) visit(use.node.name);
+          }
+          ordered.push(variable2);
+        };
+        for (const variable2 of bindings.keys()) visit(variable2);
+        const declarations = ordered.map((variable2) => {
+          const binding = bindings.get(variable2);
+          return `${binding.type} ${variable2} = ${binding.code};`;
+        });
+        const bound = `(() => {
+${declarations.join("\n")}
+return ${expanded.code};
+})()`;
+        return {
+          code: bound,
+          splices: [{ start: 0, end: code.length, text: bound }]
+        };
       }
       initializer(global) {
         const cached = this.initializers.get(global.name);
@@ -25439,7 +25494,8 @@ var init_local_values = __esm({
        * lowered, so the answer does not depend on which file lowered first: the
        * `@id` its declaration carries (through any alias chain), else the static
        * member whose initializer is the local, whose row derives from the member.
-       * `null` for a local no push has identified yet.
+       * Nested idless locals use a temporary reference resolved after their owners
+       * lower. Constructor-backed owners settle it to the materialized child ID.
        */
       declaredTarget(name) {
         const definition2 = this.definitions.get(name);
@@ -25452,7 +25508,11 @@ var init_local_values = __esm({
           return { id: id2.value, typeName };
         }
         const owners = this.ownerMembers.get(name);
-        if (owners === void 0) return null;
+        if (owners === void 0) {
+          const locator = `__pending__:local-reference:${encodeURIComponent(name)}`;
+          this.pendingReferences.set(locator, name);
+          return { id: locator, typeName };
+        }
         if (owners.length !== 1) {
           throw new Error(
             `Reference(${name}) requires exactly one owning assignment.`
@@ -25461,8 +25521,25 @@ var init_local_values = __esm({
         const owner = owners[0];
         return { ownerMemberId: owner.memberId, ownerPath: owner.path, typeName };
       }
+      remapTargets(replacements) {
+        for (const owners of this.owners.values()) {
+          for (const [id2, label] of [...owners]) {
+            const target = replacements.get(id2);
+            if (target === void 0) continue;
+            owners.delete(id2);
+            owners.set(target, label);
+          }
+        }
+      }
+      referenceTargets() {
+        return new Map(
+          [...this.pendingReferences].map(([id2, name]) => [id2, this.target(name)])
+        );
+      }
       target(name) {
-        const owners = this.owners.get(name);
+        this.inline(name);
+        const terminal2 = this.terminalInitializers.get(name)?.global.name ?? name;
+        const owners = this.owners.get(terminal2);
         if (owners?.size !== 1)
           throw new Error(
             `Reference(${name}) requires exactly one owning assignment.`
@@ -28481,15 +28558,7 @@ function calculateDeclarationSignature(ctx, projectionClassId, schemaKey, declar
     declarationClassId: declaration.classDef.id,
     memberId: declaration.memberId,
     isAbstract: isAbstractMember(member) === true,
-    isVirtual: isVirtualMember(member) !== false,
-    // Openness belongs to the DECLARING class, not to whoever is asking: a
-    // descendant that closes the param still has to see a declaration it is
-    // obliged to implement.
-    requiresClosingImplementation: lookupDeclaredTypeInfo(member) === null ? false : lookupNarrowingAwaitsClosingBinding(
-      ctx,
-      member,
-      resolveGenericEnvForEmission(ctx, declaration.classDef.id)
-    )
+    isVirtual: isVirtualMember(member) !== false
   };
   if (isCallableMemberForCodegen(member)) {
     const parameterTypes = member.argumentTypes.map(
@@ -28699,7 +28768,7 @@ function generatedInstanceMemberSignaturesEqual(left, right) {
   return false;
 }
 function emitsAbstractDeclaration(signature2) {
-  return signature2.isAbstract || signature2.requiresClosingImplementation;
+  return signature2.isAbstract;
 }
 function resolveGeneratedInstanceMemberPlan(ctx, classDef, schemaKey) {
   const declaration = ownInstanceMemberDeclaration(classDef, schemaKey);
@@ -30892,11 +30961,6 @@ function lookupHasRuntimeOwnership(member) {
 function lookupNarrowsThroughGenericParam(member) {
   return lookupDeclaredTypeInfo(member)?.type === 21 /* Generic */;
 }
-function lookupNarrowingAwaitsClosingBinding(ctx, member, env) {
-  if (!lookupNarrowsThroughGenericParam(member)) return false;
-  if (lookupProjection(ctx, member) !== "class" /* Class */) return false;
-  return lookupTargetClassProjection(ctx, member, env) === null;
-}
 function lookupTargetValueType(ctx, member, saved, env) {
   if (!isMemberLookupBase(member)) return "NeoLookupSelection";
   const targetSaved = lookupTargetSaved(ctx, member) ?? saved;
@@ -34611,7 +34675,7 @@ var init_canonical_json = __esm({
 });
 
 // ../packages/neoscript-runtime/src/neoscript/initializer-dependencies.ts
-function materializeInitializerDependencies(pending, materialize) {
+function materializeInitializerDependencies(pending, materialize, onFailure) {
   const active = /* @__PURE__ */ new Set();
   for (const rootId of pending) {
     const stack = [rootId];
@@ -34624,19 +34688,27 @@ function materializeInitializerDependencies(pending, materialize) {
         active.delete(valueId);
         stack.pop();
       } catch (error) {
-        if (!(error instanceof PendingInitializerDependency)) throw error;
-        if (!pending.has(error.valueId)) throw error;
-        if (active.has(error.valueId)) {
+        if (error instanceof PendingInitializerDependency && pending.has(error.valueId)) {
+          if (!active.has(error.valueId)) {
+            active.add(error.valueId);
+            stack.push(error.valueId);
+            continue;
+          }
           const cycle = new NSGetterRuntimeError(
             `Initializer dependency cycle: ${[...stack, error.valueId].join(" -> ")}. Remove a dependency so these values can be initialized in order.`
           );
           cycle.initializerValueId = valueId;
           cycle.node = error.node;
           cycle.source = error.source;
-          throw cycle;
+          error = cycle;
+        }
+        if (onFailure === void 0) throw error;
+        onFailure(stack, error);
+        for (const id2 of stack) {
+          pending.delete(id2);
+          active.delete(id2);
         }
-        active.add(error.valueId);
-        stack.push(error.valueId);
+        stack.length = 0;
       }
     }
   }
@@ -39374,6 +39446,7 @@ function indexRuntimeCollectionChange(collection, entry, ctx, removedEntries = n
     indexes4.memberByRowId.clear();
   }
   if (Array.isArray(collection)) forgetLocalListIndexes(ctx, collection);
+  else indexes4.declaredListByArray = /* @__PURE__ */ new WeakMap();
   markOverlayMutated(ctx, collection);
   if (ctx.__valueOverlay instanceof LazyValueOverlay)
     indexes4.overlayRevision = ctx.__valueOverlay.revision;
@@ -40831,11 +40904,10 @@ function remapRuntimeReferences(value, overlay2, seen, preservedReferences) {
   const next = {};
   seen.set(value, next);
   for (const [key, entry] of Object.entries(value)) {
-    next[key] = remapRuntimeReferences(
-      entry,
-      overlay2,
-      seen,
-      preservedReferences
+    setOwnField(
+      next,
+      key,
+      remapRuntimeReferences(entry, overlay2, seen, preservedReferences)
     );
   }
   return next;
@@ -42635,7 +42707,7 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
     if (entryId !== null) {
       const collection = Array.isArray(receiver) ? receiver : objectArg(receiver, "Assignment target");
       const entryKey = typeof key === "number" ? key : String(key);
-      Reflect.set(collection, String(entryKey), entryId);
+      setOwnField(collection, String(entryKey), entryId);
       recordWrittenEntry(collection, entryKey, true, ctx);
       if (!indexRuntimeCollectionChange(
         collection,
@@ -42731,7 +42803,7 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
       );
       noteDetachedRow(object2[stringKey], referenceValueId, ctx);
     }
-    object2[stringKey] = referenceValueId;
+    setOwnField(object2, stringKey, referenceValueId);
     if (!field) recordWrittenEntry(object2, stringKey, true, ctx);
     if (field || !indexRuntimeCollectionEntryWrite(
       object2,
@@ -42747,7 +42819,7 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
     return;
   if (field && (targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 22 /* Interface */))
     noteDetachedRow(object2[stringKey], value, ctx);
-  object2[stringKey] = value;
+  setOwnField(object2, stringKey, value);
   if (!field) recordWrittenEntry(object2, stringKey, false, ctx);
   const scalarField = (previous == null || typeof previous === "number" || typeof previous === "boolean" || typeof previous === "string") && (value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "string");
   if (field && !scalarField || !indexRuntimeCollectionEntryWrite(object2, previous, value, stringKey, ctx))
@@ -42829,7 +42901,7 @@ function copiedCollectionContents(source, entryTypeInfo, slotId, ctx) {
       }
     }
     if (Array.isArray(copy)) copy.push(entry);
-    else copy[String(key)] = entry;
+    else setOwnField(copy, String(key), entry);
     return 0 /* Continue */;
   });
   const cache = unorderedListProjectionCache(ctx);
@@ -42898,107 +42970,6 @@ function keepAssignedCollectionValues(value, targetTypeInfo, row, ctx) {
     return 0 /* Continue */;
   });
 }
-function pendingConstructorRootsForRow(valueId, ctx) {
-  const roots = /* @__PURE__ */ new Set();
-  const open2 = ctx.__executionState?.openConstructions;
-  if (open2 === void 0 || open2.size === 0) return roots;
-  const visited = /* @__PURE__ */ new Set();
-  const pending = [valueId];
-  const parentEntries = /* @__PURE__ */ new Map();
-  const placingMembers = /* @__PURE__ */ new Map();
-  while (pending.length > 0) {
-    const id2 = pending.pop();
-    if (id2 === void 0 || visited.has(id2)) continue;
-    visited.add(id2);
-    const row = evalValueById(
-      ctx,
-      id2,
-      ctx.__runtimeSessionValues,
-      ctx.__valueOverlay
-    );
-    if (row === null) continue;
-    if (typeof row.value === "object" && row.value !== null && open2.has(row.value))
-      roots.add(id2);
-    for (const owner of currentOwnedValueAttachments(
-      id2,
-      ctx,
-      parentEntries,
-      placingMembers
-    )) {
-      if (!owner.identity.startsWith("value:")) continue;
-      const parent = evalValueById(
-        ctx,
-        owner.label,
-        ctx.__runtimeSessionValues,
-        ctx.__valueOverlay
-      );
-      if (parent === null) continue;
-      if (parent.classId === void 0 || parent.classId === null) {
-        const raw = placingMember(
-          parent,
-          ctx,
-          void 0,
-          0,
-          placingMembers,
-          parentEntries
-        );
-        if (raw === null) continue;
-        const member = raw.kind === 21 /* Generic */ ? substituteMember(raw, rowGenericEnv(parent, ctx), ctx.vm.members) : resolveMember(raw, ctx.vm.members);
-        if (isMemberWithEntries(member)) {
-          const rawEntry = evalMemberById(ctx.vm, member.entryMemberId);
-          if (rawEntry === null) continue;
-          const entry = rawEntry.kind === 21 /* Generic */ ? substituteMember(
-            rawEntry,
-            rowGenericEnv(parent, ctx),
-            ctx.vm.members
-          ) : resolveMember(rawEntry, ctx.vm.members);
-          if (entry.kind === 21 /* Generic */ || isMemberLookupBase(entry))
-            continue;
-        }
-      }
-      pending.push(owner.label);
-    }
-    for (const link of evaluatorParentLinks(evaluatorIndexes(ctx), id2)) {
-      const parent = evalValueById(
-        ctx,
-        link.parentId,
-        ctx.__runtimeSessionValues,
-        ctx.__valueOverlay
-      );
-      if (parent === null || !Array.isArray(parent.value)) continue;
-      const member = placingMember(
-        parent,
-        ctx,
-        void 0,
-        0,
-        placingMembers,
-        parentEntries
-      );
-      if (member === null || !isMemberTupleBase(member)) continue;
-      const positions = ownershipParentEntryKeys(
-        parent.value,
-        id2,
-        parentEntries
-      );
-      for (const position of positions ?? []) {
-        if (typeof position !== "number") continue;
-        const entryId = member.elementMemberIds[position];
-        const rawEntry = entryId === void 0 ? null : evalMemberById(ctx.vm, entryId);
-        if (rawEntry === null) continue;
-        const entry = rawEntry.kind === 21 /* Generic */ ? substituteMember(
-          rawEntry,
-          rowGenericEnv(parent, ctx),
-          ctx.vm.members
-        ) : resolveMember(rawEntry, ctx.vm.members);
-        if (entry.kind === 21 /* Generic */ || isMemberLookupBase(entry))
-          continue;
-        pending.push(parent.id);
-        break;
-      }
-    }
-  }
-  return roots;
-}
 function preflightAssignedCollection(collection, member, row, ctx) {
   if (member === null) return;
   const env = rowGenericEnv(row, ctx);
@@ -43011,8 +42982,6 @@ function preflightAssignedCollection(collection, member, row, ctx) {
   const attached = /* @__PURE__ */ new Set();
   const preflight = {
     parentEntries: /* @__PURE__ */ new Map(),
-    constructorRootIds: pendingConstructorRootsForRow(row.id, ctx),
-    constructorArgumentTransfers: /* @__PURE__ */ new Map(),
     dependencies: /* @__PURE__ */ new Map()
   };
   forEachRawCollectionEntry(collection, ctx, ({ raw, key, valueId }) => {
@@ -43035,8 +43004,6 @@ function preflightAssignedCollection(collection, member, row, ctx) {
     );
     return 0 /* Continue */;
   });
-  for (const [id2, destination] of preflight.constructorArgumentTransfers)
-    ctx.__executionState?.ownedValueAttachments.set(id2, destination);
   for (const [id2, destination] of preflight.dependencies)
     recordConstructorGroupDependency(id2, destination, ctx);
 }
@@ -43064,6 +43031,7 @@ function replaceRowValue(row, value, receiver, ctx) {
   unindexEvaluatorRow(indexes4, row, true);
   row.value = value;
   indexEvaluatorRow(indexes4, row, true);
+  indexes4.declaredListByArray = /* @__PURE__ */ new WeakMap();
   markOverlayMutated(ctx, receiver);
   if (ctx.__valueOverlay instanceof LazyValueOverlay)
     indexes4.overlayRevision = ctx.__valueOverlay.revision;
@@ -44874,7 +44842,11 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
         }
         return null;
       }
-      objectArg(targetValue, "Dictionary Add target")[String(args[0])] = args[1];
+      setOwnField(
+        objectArg(targetValue, "Dictionary Add target"),
+        String(args[0]),
+        args[1]
+      );
       return null;
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
@@ -47298,6 +47270,17 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
     case 8 /* Enum */:
       return Array.isArray(value) && value.every((v) => typeof v === "string");
     case 7 /* Class */: {
+      if (isVariantClassId(checkType.classId)) {
+        if (!isVariantRefValue(value)) return false;
+        const targetParameter = evaluatorSchemaIndex(ctx).classesById.get(
+          checkType.classId
+        )?.genericParams?.[0];
+        const target = targetParameter === void 0 ? void 0 : receiverClosedTypeArguments(checkType.typeArguments, ctx)?.[targetParameter.id];
+        return target?.type !== 7 /* Class */ || evaluatorSchemaIndex(ctx).classIsOrExtends(
+          value.classId,
+          target.classId
+        );
+      }
       if (typeof value !== "object") return false;
       const row = trackedRowForValueReference(value, ctx);
       const runtimeClassId = row === null ? void 0 : classIdForValueRow(row, ctx);
@@ -51206,6 +51189,7 @@ function publishConstructedRows(args) {
   if (beforeRetain !== null) {
     for (const rowId of beforeRetain) {
       if (retained.has(rowId)) continue;
+      if (constructorGroupForRow(rowId, ctx) !== null) continue;
       deleteRuntimeSessionValue(ctx, rowId);
     }
   }
@@ -51291,16 +51275,55 @@ function assertImplicitConstructionAllowed(schemaClass2) {
     `Class '${schemaClass2.name}' declares a required constructor, so it cannot be constructed without one.`
   );
 }
+function constructionReplayContext(descriptor, ctx) {
+  if (ctx.storedConstructionReplay !== true) return ctx;
+  const target = ctx.__storedInitializerReplay;
+  let rowId;
+  let candidate;
+  if (target !== void 0) {
+    const row = storedReplayRowById(target.rowId, ctx);
+    if (row !== null && classIdForValueRow(row, ctx) === descriptor.schemaClass.id) {
+      rowId = target.rowId;
+      candidate = { reattached: false };
+      target.candidates.push(candidate);
+    }
+  } else if (ctx.__executionState?.constructionStack.length === 0 && ctx.__storedConstructionReplaySlot?.classId === descriptor.schemaClass.id) {
+    rowId = ctx.__storedConstructionReplayRowId;
+  }
+  return {
+    ...ctx,
+    __storedInitializerReplay: void 0,
+    __storedReplayCandidate: candidate,
+    __storedConstructionReplayRowId: rowId,
+    __storedConstructionReplayRootId: void 0,
+    __storedConstructionReplaySlot: rowId === void 0 ? ctx.__storedConstructionReplaySlot : {
+      classId: descriptor.schemaClass.id,
+      classArguments: descriptor.classArguments ?? {}
+    }
+  };
+}
+function rollbackStoredConstructionReplay(ctx, checkpoint) {
+  if (checkpoint === void 0) return;
+  for (const row of createdSessionValuesSince(ctx, checkpoint))
+    deleteRuntimeSessionValue(ctx, row.id);
+  if (ctx.__storedReplayCandidate !== void 0)
+    ctx.__storedReplayCandidate.reattached = false;
+}
 function constructClassValue(info, scope, ctx) {
   const descriptor = validateClassConstructorDescriptor(
     info,
     ctx,
     ctx.constructionBaselineReplay !== true
   );
+  ctx = constructionReplayContext(descriptor, ctx);
   assertImplicitConstructionAllowed(descriptor.schemaClass);
+  const replayCheckpoint = ctx.__storedConstructionReplayRowId === void 0 ? void 0 : sessionCreationCheckpoint(ctx);
   const closeFrame = pushConstructionFrame(ctx, descriptor.schemaClass.name);
   try {
     return constructClassValueWithinFrame(descriptor, scope, ctx);
+  } catch (error) {
+    rollbackStoredConstructionReplay(ctx, replayCheckpoint);
+    throw error;
   } finally {
     closeFrame();
   }
@@ -51400,6 +51423,8 @@ function constructClassValueWithinFrame(descriptor, scope, ctx) {
     });
     root.classId = classId;
     stampConstructedRootGenericBindings(root, descriptor);
+    if (ctx.__storedReplayCandidate !== void 0)
+      ctx.__storedReplayCandidate.value = root.value;
     if (typeof root.value !== "object" || root.value === null || Array.isArray(root.value)) {
       throw new Error(
         `Class constructor for '${schemaClass2.name}' produced a non-record root.`
@@ -51829,15 +51854,20 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
       sourceValueId: sourceValueId ?? null,
       compileMemberId: scopeMemberId
     });
+    const childId = storedInitializerChildId(member, ctx);
+    const initializerCtx = childId === void 0 ? ctx : {
+      ...ctx,
+      __storedInitializerReplay: { rowId: childId, candidates: [] }
+    };
     const evaluate = (argumentValues = []) => {
-      return withConstructionGenericSlots(
+      const result = withConstructionGenericSlots(
         member,
-        ctx,
+        initializerCtx,
         genericEnv,
         () => evaluateInitializerInContext(
           init,
           member,
-          ctx,
+          initializerCtx,
           createdValues,
           argumentValues,
           sourceValueId ?? null,
@@ -51845,6 +51875,17 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
           genericEnv
         )
       );
+      for (const candidate of initializerCtx.__storedInitializerReplay?.candidates ?? []) {
+        if (!candidate.reattached) continue;
+        if (candidate.value !== result.value) {
+          throw new NSGetterRuntimeError(
+            `Stored initializer '${member.name}' constructed an already owned value outside its returned child. Call Clone() explicitly.`
+          );
+        }
+        if (ctx.__storedReplayCandidate !== void 0)
+          ctx.__storedReplayCandidate.reattached = true;
+      }
+      return result;
     };
     const ownerClassId = scopeMemberId === null ? null : owningClassId(scopeMemberId);
     const expectedArgumentCount = compiled.parameters.slice(2).length;
@@ -52057,6 +52098,13 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
       (argument2) => trackedRowForValueReference(argument2, ctx)?.id === existingValueRow.id
     )) {
       assertInitializerPlacement(existingValueRow.id, member, ctx);
+      if (storedInitializerChildId(member, ctx) === existingValueRow.id) {
+        return {
+          value: result.value,
+          classId: existingRuntimeClassId,
+          existingValueRow
+        };
+      }
     }
     if (existingValueRow !== null && existingRuntimeClassId !== null && isClassSlotMember(member)) {
       const storage = constructorArgumentStorage(existingValueRow.id, ctx);
@@ -52260,18 +52308,14 @@ function encodeRequiredConstructorArgument(args) {
     args.ctx.__valueOverlay
   ) !== null ? args.value : null;
   const adoptTracked = (id2, suffix) => {
-    if (constructorGroupForRow(id2, args.ctx) !== null) {
-      assertOwnedValueAttachable(
-        id2,
-        {
-          identity: `value:${args.ownerRootId}:constructorArg:${args.parameterId}:${suffix}`,
-          label: args.ownerRootId
-        },
-        `constructor argument '${args.parameterId}'`,
-        args.ctx,
-        true
-      );
-    }
+    recordConstructorGroupDependency(
+      id2,
+      {
+        identity: `value:${args.ownerRootId}:constructorArg:${args.parameterId}:${suffix}`,
+        label: args.ownerRootId
+      },
+      args.ctx
+    );
     return id2;
   };
   if (args.typeInfo.type === 21 /* Generic */) {
@@ -52279,6 +52323,21 @@ function encodeRequiredConstructorArgument(args) {
       `Constructor argument '${args.parameterId}' has an unresolved generic type.`
     );
   }
+  if (args.typeInfo.type === 7 /* Class */ && isVariantClassId(args.typeInfo.classId)) {
+    if (args.value === null || args.value === void 0) return null;
+    const selection2 = readVariantSelection(
+      args.value,
+      `Constructor argument '${args.parameterId}'`
+    );
+    if (selection2.rowValueId !== null) {
+      adoptTracked(selection2.rowValueId, "variant-row");
+    }
+    return {
+      classId: selection2.classId,
+      variantId: selection2.variantId,
+      ...selection2.rowValueId === null ? {} : { rowValueId: selection2.rowValueId }
+    };
+  }
   if (args.typeInfo.type === 7 /* Class */ || args.typeInfo.type === 22 /* Interface */) {
     if (args.value === null || args.value === void 0) return null;
     const aggregateId2 = trackedId ?? replayedAggregateId;
@@ -53192,7 +53251,8 @@ function constructDeclaredClassValue(info, scope, ctx) {
   const descriptor = validateClassConstructorDescriptor(info, ctx, false);
   const schemaClass2 = descriptor.schemaClass;
   const record7 = resolveDeclaredConstructorRecord(info, schemaClass2, ctx);
-  const replayCheckpoint = ctx.storedConstructionReplay === true && ctx.__storedConstructionReplayRowId !== void 0 && ctx.__storedConstructionReplaySlot?.classId === schemaClass2.id && ctx.__executionState?.constructionStack.length === 0 ? sessionCreationCheckpoint(ctx) : void 0;
+  ctx = constructionReplayContext(descriptor, ctx);
+  const replayCheckpoint = ctx.storedConstructionReplay === true && ctx.__storedConstructionReplayRowId !== void 0 && ctx.__storedConstructionReplaySlot?.classId === schemaClass2.id ? sessionCreationCheckpoint(ctx) : void 0;
   const closeFrame = pushConstructionFrame(ctx, schemaClass2.name);
   try {
     return constructDeclaredClassValueWithinFrame(
@@ -53203,11 +53263,7 @@ function constructDeclaredClassValue(info, scope, ctx) {
       ctx
     );
   } catch (error) {
-    if (replayCheckpoint !== void 0) {
-      for (const row of createdSessionValuesSince(ctx, replayCheckpoint)) {
-        deleteRuntimeSessionValue(ctx, row.id);
-      }
-    }
+    rollbackStoredConstructionReplay(ctx, replayCheckpoint);
     throw error;
   } finally {
     closeFrame();
@@ -53268,6 +53324,8 @@ function constructDeclaredClassValueWithinFrame(descriptor, record7, info, scope
     });
     root.classId = classId;
     stampConstructedRootGenericBindings(root, descriptor);
+    if (ctx.__storedReplayCandidate !== void 0)
+      ctx.__storedReplayCandidate.value = root.value;
   } catch (error) {
     if (error instanceof NSGetterRuntimeError) {
       positionAtPassingArgument(error, info, record7, argumentValues, ctx);
@@ -53280,7 +53338,7 @@ function constructDeclaredClassValueWithinFrame(descriptor, record7, info, scope
       `Declared constructor for '${schemaClass2.name}' produced a non-record root.`
     );
   }
-  if (ctx.storedConstructionReplay === true && ctx.__storedConstructionReplayRowId !== void 0 && ctx.__storedConstructionReplaySlot?.classId === classId && ctx.__executionState?.constructionStack.length === 1) {
+  if (ctx.storedConstructionReplay === true && ctx.__storedConstructionReplayRowId !== void 0 && ctx.__storedConstructionReplaySlot?.classId === classId) {
     ctx = { ...ctx, __storedConstructionReplayRootId: root.id };
   }
   const rootRecord = root.value;
@@ -53444,8 +53502,13 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
     ctx,
     preflight?.parentEntries
   )) {
-    if (mode === "assign" && ownedAttachmentIdentity(owner, ctx) === ownedAttachmentIdentity(destination, ctx))
+    if (mode === "assign" && ownedAttachmentIdentity(owner, ctx) === ownedAttachmentIdentity(destination, ctx)) {
+      if (ctx.__storedReplayCandidate !== void 0 && ctx.__storedConstructionReplayRowId !== void 0 && owner.identity.startsWith(
+        `value:${ctx.__storedConstructionReplayRowId}:slot:`
+      ))
+        ctx.__storedReplayCandidate.reattached = true;
       continue;
+    }
     const error = new NSGetterRuntimeError(
       `Aggregate value '${valueId}' is already owned by parent value '${owner.label}' and cannot be attached to '${destinationName2}'. Call Clone() explicitly.`
     );
@@ -53454,23 +53517,6 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
   }
   const reserved = ctx.__executionState?.ownedValueAttachments.get(valueId);
   if (reserved !== void 0 && (mode === "insert" || reserved.identity !== destination.identity)) {
-    const constructorArgumentReservation = reserved.identity.startsWith(
-      `value:${reserved.label}:constructorArg:`
-    );
-    const destinationConstructorGroup = constructorGroupForRow(
-      destination.label,
-      ctx
-    );
-    if (constructorArgumentReservation && (destination.label === reserved.label || destinationConstructorGroup === reserved.label || preflight?.constructorRootIds.has(reserved.label) === true)) {
-      if (preflight === void 0) {
-        ctx.__executionState?.ownedValueAttachments.set(valueId, destination);
-        recordConstructorGroupDependency(valueId, destination, ctx);
-      } else {
-        preflight.constructorArgumentTransfers.set(valueId, destination);
-        preflight.dependencies.set(valueId, destination);
-      }
-      return;
-    }
     throw new NSGetterRuntimeError(
       `Aggregate value '${valueId}' is already owned by parent value '${reserved.label}' and cannot be attached to '${destinationName2}'. Call Clone() explicitly.`
     );
@@ -53482,6 +53528,29 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
     recordConstructorGroupDependency(valueId, destination, ctx);
   else preflight.dependencies.set(valueId, destination);
 }
+function storedReplayRowById(id2, ctx) {
+  ctx.valueDependencies?.add(id2);
+  ctx.__getterReads?.add(id2);
+  const database = ctx.vm.databaseVM;
+  if (database?.storedValueById !== void 0)
+    return database.storedValueById(id2);
+  if (database?.evaluatorIndexes !== void 0)
+    return database.evaluatorIndexes.valueById.get(id2) ?? null;
+  return ctx.vm.values.find((row) => row.id === id2) ?? null;
+}
+function storedInitializerChildId(member, ctx) {
+  if (ctx.storedConstructionReplay !== true) return void 0;
+  const parentId = ctx.__storedConstructionReplayRowId;
+  const memberId = Reflect.get(member, "id");
+  if (parentId === void 0 || typeof memberId !== "string") return void 0;
+  const parent = storedReplayRowById(parentId, ctx);
+  if (parent?.value === null || typeof parent?.value !== "object")
+    return void 0;
+  const schemaKey = cachedSchemaKeyForMember(memberId, ctx);
+  if (schemaKey === null) return void 0;
+  const childId = Reflect.get(parent.value, schemaKey);
+  return typeof childId === "string" ? childId : void 0;
+}
 function assertInitializerPlacement(valueId, member, ctx) {
   const replayRowId = ctx.__storedConstructionReplayRowId;
   const memberId = Reflect.get(member, "id");
@@ -53518,7 +53587,7 @@ function ownershipParentEntryKeys(value, valueId, cache) {
   }
   return entries.get(valueId) ?? [];
 }
-function currentOwnedValueAttachments(valueId, ctx, parentEntries, placingMembers) {
+function currentOwnedValueAttachments(valueId, ctx, parentEntries) {
   const indexes4 = evaluatorIndexes(ctx);
   const cached = indexes4.ownedValueAttachmentsByValueId.get(valueId);
   if (cached !== void 0) return [...cached];
@@ -53581,14 +53650,7 @@ function currentOwnedValueAttachments(valueId, ctx, parentEntries, placingMember
     let member = null;
     let classId = parent.classId;
     if (classId === void 0 || classId === null) {
-      member = activeStaticBindingRoot(parent.id, ctx)?.member ?? (placingMembers === void 0 ? memberForValueRow(parent, ctx) : placingMember(
-        parent,
-        ctx,
-        void 0,
-        0,
-        placingMembers,
-        parentEntries
-      ));
+      member = activeStaticBindingRoot(parent.id, ctx)?.member ?? memberForValueRow(parent, ctx);
       if (member !== null) {
         try {
           member = resolveMember(member, ctx.vm.members);
@@ -57052,22 +57114,29 @@ var init_lookup_declared_type = __esm({
 });
 
 // ../packages/neoscript-runtime/src/values/member-declared-type-info.ts
-function resolveMemberDeclaredTypeInfo(member, members2, ownerClass = null, env) {
+function resolveMemberDeclaredTypeInfo(member, members2, classes, ownerClass = null, env) {
   return resolveMemberDeclaredTypeInfoInternal(
     member,
     members2,
+    classes,
     /* @__PURE__ */ new Set(),
     ownerClass,
     env,
     ownerClass === null ? void 0 : classConstrainedGenerics([ownerClass])
   );
 }
-function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClass, env, isClassConstrained) {
+function resolveMemberDeclaredTypeInfoInternal(member, members2, classes, seen, ownerClass, env, isClassConstrained) {
   const resolved = env === void 0 ? resolveMember(member, members2) : substituteMember(member, env, members2);
   const memberId = getField(resolved, "id");
   if (typeof memberId === "string" && seen.has(memberId)) return null;
   const nextSeen = typeof memberId === "string" ? /* @__PURE__ */ new Set([...seen, memberId]) : new Set(seen);
   if (isMemberNSPropertyBase(resolved)) return resolved.returnTypeInfo;
+  if (isMemberVariantBase(resolved)) {
+    return variantMemberDeclaredTypeInfo(
+      resolved,
+      neoVariantSystemClass(classes, resolved.valueTypeInfo != null)
+    );
+  }
   if (isClassSlotMember(resolved)) {
     const typeArguments = Object.fromEntries(
       Object.entries(declaredSlotArguments(resolved) ?? {}).flatMap(
@@ -57087,6 +57156,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
           const argumentType2 = resolveMemberDeclaredTypeInfoInternal(
             argumentMember,
             members2,
+            classes,
             nextSeen,
             ownerClass,
             env,
@@ -57157,6 +57227,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
       const typeInfo = resolveMemberDeclaredTypeInfoInternal(
         descriptor,
         members2,
+        classes,
         nextSeen,
         ownerClass,
         env,
@@ -57185,6 +57256,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
     const entryTypeInfo = resolveMemberDeclaredTypeInfoInternal(
       entry,
       members2,
+      classes,
       nextSeen,
       ownerClass,
       env,
@@ -57209,6 +57281,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
         return resolveMemberDeclaredTypeInfoInternal(
           collection,
           members2,
+          classes,
           nextSeen,
           ownerClass,
           env,
@@ -57257,6 +57330,7 @@ var init_member_declared_type_info = __esm({
     init_inheritance();
     init_parameter_defaults();
     init_core();
+    init_variant_member();
   }
 });
 
@@ -57265,6 +57339,15 @@ function recordEntries(value) {
   if (typeof value !== "object" || value === null) return [];
   return Object.values(value);
 }
+function isVariantArgument(value, typeInfo) {
+  return typeInfo?.type === 7 /* Class */ && isVariantClassId(typeInfo.classId) && isVariantRefValue(value);
+}
+function remapVariantArgument(value, typeInfo, remap) {
+  if (!isVariantArgument(value, typeInfo)) return value;
+  if (typeof value.rowValueId !== "string") return value;
+  const rowValueId = remap(value.rowValueId);
+  return rowValueId === value.rowValueId ? value : { ...value, rowValueId };
+}
 function resolveSemanticOwnerMembersForValues(document, targetValueIds, additionalRoots, rootOwners, rootKinds, graphOf = () => new MaterializedValueGraphContext(
   document,
   void 0,
@@ -57576,7 +57659,11 @@ function tryResolveTypeInfo(document, rawTypeInfo, env) {
 function tryMemberTypeInfo(document, rawMember, env) {
   try {
     const member = substituteMember(rawMember, env, document.members);
-    const typeInfo = resolveMemberDeclaredTypeInfo(member, document.members);
+    const typeInfo = resolveMemberDeclaredTypeInfo(
+      member,
+      document.members,
+      document.classes
+    );
     if (typeInfo === null) return null;
     return tryResolveTypeInfo(document, typeInfo, env);
   } catch {
@@ -57616,6 +57703,7 @@ var init_constructor_argument_ownership = __esm({
     init_core();
     init_interface_implementers();
     init_members();
+    init_reference_category();
     init_neoscript();
     init_project_schema_index();
     init_member_declared_type_info();
@@ -57856,7 +57944,7 @@ var init_constructor_argument_ownership = __esm({
               const typeInfo = parameterTypes.get(parameterId);
               return [
                 parameterId,
-                typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
+                typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : remapVariantArgument(argument2, typeInfo, rewriteId)
               ];
             }
           )
@@ -57892,15 +57980,18 @@ var init_constructor_argument_ownership = __esm({
           ids.push(edge.targetValueId);
         return ids;
       }
-      /** The targets a row's Reference creation data names (P112 §1.1). */
+      /** Reference targets and bound lookup rows retained by creation data. */
       referenceArgumentIds(row) {
         if (!isLiteralValueContent(row)) return [];
         const args = row.constructorArgs;
         if (args === void 0 || args === null) return [];
         const ids = [];
-        for (const parameterId of this.referenceParameterIds(row)) {
+        for (const [parameterId, typeInfo] of this.constructorParameterTypes(row)) {
           const argument2 = args[parameterId];
-          if (typeof argument2 === "string") ids.push(argument2);
+          if (typeInfo.type === 29 /* Reference */ && typeof argument2 === "string")
+            ids.push(argument2);
+          else if (isVariantArgument(argument2, typeInfo) && typeof argument2.rowValueId === "string")
+            ids.push(argument2.rowValueId);
         }
         return ids;
       }
@@ -57909,23 +58000,23 @@ var init_constructor_argument_ownership = __esm({
         const args = row.constructorArgs;
         if (args === void 0 || args === null) return args;
         let remapped;
-        for (const parameterId of this.referenceParameterIds(
+        for (const [parameterId, typeInfo] of this.constructorParameterTypes(
           row,
           contextualMember
         )) {
           const argument2 = args[parameterId];
-          if (typeof argument2 !== "string") continue;
-          const target = remap(argument2);
+          const target = typeInfo.type === 29 /* Reference */ && typeof argument2 === "string" ? remap(argument2) : remapVariantArgument(argument2, typeInfo, remap);
           if (target !== argument2) (remapped ??= { ...args })[parameterId] = target;
         }
         return remapped ?? args;
       }
-      *referenceParameterIds(row, contextualMember) {
-        for (const [parameterId, typeInfo] of this.constructorParameterTypes(
-          row,
-          contextualMember
-        ))
-          if (typeInfo.type === 29 /* Reference */) yield parameterId;
+      *variantArgumentSelections(row) {
+        if (!isLiteralValueContent(row)) return;
+        if (row.constructorArgs == null) return;
+        for (const [parameterId, typeInfo] of this.constructorParameterTypes(row)) {
+          const argument2 = row.constructorArgs[parameterId];
+          if (isVariantArgument(argument2, typeInfo)) yield argument2;
+        }
       }
       slotEntries(row) {
         const value = row.value;
@@ -58026,6 +58117,17 @@ var init_constructor_argument_ownership = __esm({
           if (member === void 0) return null;
           return this.memberTypeInfo(member, env);
         }
+        if ((rawTypeInfo.type === 7 /* Class */ || rawTypeInfo.type === 22 /* Interface */) && rawTypeInfo.typeArguments !== void 0) {
+          const typeArguments = {};
+          for (const [parameterId, argument2] of Object.entries(
+            rawTypeInfo.typeArguments
+          )) {
+            const resolved = this.resolveTypeInfo(argument2, env);
+            if (resolved === null) return null;
+            typeArguments[parameterId] = resolved;
+          }
+          return { ...rawTypeInfo, typeArguments };
+        }
         if (rawTypeInfo.type === 30 /* Tuple */) {
           const elements = [];
           for (const element of rawTypeInfo.elements) {
@@ -58057,7 +58159,8 @@ var init_constructor_argument_ownership = __esm({
           const member = substituteMember(rawMember, env, this.document.members);
           const typeInfo = resolveMemberDeclaredTypeInfo(
             member,
-            this.document.members
+            this.document.members,
+            this.document.classes
           );
           return typeInfo === null ? null : this.resolveTypeInfo(typeInfo, env);
         } catch {
@@ -63152,7 +63255,7 @@ function indexedInitializerEvaluatorLookups(document, key, revision) {
   });
   return lookups;
 }
-function createInitializerMaterializationBatch(authoredDocument, pendingInitializerIds) {
+function createInitializerMaterializationBatch(authoredDocument, pendingInitializerIds, referenceOwners) {
   const indexed = createInitializerBatchLookups(authoredDocument);
   let hasListenerMetadata;
   const unorderedListEntryIds2 = indexed.snapshot().unorderedListEntryIds;
@@ -63302,7 +63405,12 @@ function createInitializerMaterializationBatch(authoredDocument, pendingInitiali
           base.valueById(id2),
           (id3) => virtual().declarationDefaultGraph(id3, member)
         ),
-        valueById: (id2) => base.valueById(id2) ?? expandedById.get(id2) ?? virtual().valueById(id2),
+        valueById: (id2) => {
+          const owner = referenceOwners?.get(id2);
+          if (owner !== void 0 && pendingInitializerIds?.has(owner))
+            throw new PendingInitializerDependency(owner);
+          return base.valueById(id2) ?? expandedById.get(id2) ?? virtual().valueById(id2);
+        },
         rowForValueReference: (value) => base.rowForValueReference(value) ?? expandedByReference.get(value) ?? virtual().rowForValueReference(value),
         virtualInstanceRowsForValue: (id2) => {
           const cached = cachedById.get(id2);
@@ -63682,13 +63790,37 @@ function derivedGenericArgumentMemberId(parentRecordId, genericParamId) {
     )
   );
 }
-var NEO_GENERIC_ARGUMENT_MEMBER_NAMESPACE;
+function pendingGenericArgumentMemberId(parentRecordId, genericParamId) {
+  return `${PENDING_GENERIC_ARGUMENT_PREFIX}${encodeURIComponent(parentRecordId)}:${encodeURIComponent(genericParamId)}`;
+}
+function pendingGenericArgumentIdentity(token) {
+  if (!token.startsWith(PENDING_GENERIC_ARGUMENT_PREFIX)) return null;
+  const parts = token.slice(PENDING_GENERIC_ARGUMENT_PREFIX.length).split(":");
+  if (parts.length !== 2)
+    throw new Error(
+      `Pending generic argument identity must have two components: ${token}.`
+    );
+  if (!parts[0])
+    throw new Error(
+      `Pending generic argument identity has no parent: ${token}.`
+    );
+  if (!parts[1])
+    throw new Error(
+      `Pending generic argument identity has no parameter: ${token}.`
+    );
+  return {
+    parentRecordId: decodeURIComponent(parts[0]),
+    genericParamId: decodeURIComponent(parts[1])
+  };
+}
+var NEO_GENERIC_ARGUMENT_MEMBER_NAMESPACE, PENDING_GENERIC_ARGUMENT_PREFIX;
 var init_generic_argument_member_id = __esm({
   "../src/models/members/generic-argument-member-id.ts"() {
     "use strict";
     init_dist_node();
     init_system_record_id();
     NEO_GENERIC_ARGUMENT_MEMBER_NAMESPACE = "6a4e1d38-9b52-5c0f-8d71-3e2a7f4b6c19";
+    PENDING_GENERIC_ARGUMENT_PREFIX = "__pending__:generic-argument-member:";
   }
 });
 
@@ -69866,8 +69998,8 @@ var init_strict_resolver = __esm({
           this.persistingMethodGroup = false;
         }
       }
-      /** P112 §2.2. Checks a stored default's `Reference(place)` the push can't settle. */
-      resolvePersistedReference(expression, expected) {
+      /** Check an initializer with its expected type, including contextual expressions. */
+      validateInitializerExpression(expression, expected) {
         const resolved = this.resolveExpression(
           expression,
           this.initialScope(),
@@ -74969,11 +75101,97 @@ var init_strict_resolver = __esm({
         if (callee.kind !== "member") return null;
         const isInitialize = callee.name === VARIANT_INITIALIZE_NAME;
         const isApply = callee.name === VARIANT_APPLY_NAME;
-        if (!isInitialize && !isApply) return null;
+        const isBind = callee.name === "Bind";
+        if (!isInitialize && !isApply && !isBind) return null;
         if (callee.receiver.kind === "ident" && !this.hasValueReceiver(callee.receiver.name, scope) && this.project.typeByName.has(callee.receiver.name)) {
           return null;
         }
         const receiver = receiverValue ? receiverValue() : this.resolveExpression(callee.receiver, scope);
+        if (isBind) {
+          const variantInfo2 = this.variantTypeInfo(receiver.type);
+          if (variantInfo2 === null) return null;
+          if (variantInfo2.valueType === null) {
+            throw new CompileError("Only a lookup variant can bind a row.", pos);
+          }
+          if (callee.optional === true) {
+            throw new CompileError("Bind requires a non-null lookup variant.", pos);
+          }
+          if (receiver.pointer.type !== "variant" /* Variant */) {
+            throw new CompileError(
+              "Bind requires a declared lookup variant path.",
+              pos
+            );
+          }
+          requireArgCount("NeoLookupVariant.Bind", argumentsList2, 1, pos);
+          const row2 = argumentsList2[0];
+          if (row2.kind !== "call") {
+            throw new CompileError(
+              'Bind requires Reference(id: "value-id").',
+              row2.pos
+            );
+          }
+          if (row2.callee.kind !== "ident" || row2.callee.name !== "Reference") {
+            throw new CompileError(
+              "Bind requires a Reference row argument.",
+              row2.pos
+            );
+          }
+          requireArgCount("Bind Reference", row2.args, 1, row2.pos);
+          if (row2.argumentNames?.[0] !== "id") {
+            throw new CompileError(
+              'Bind requires Reference(id: "value-id").',
+              row2.pos
+            );
+          }
+          const id2 = row2.args[0];
+          if (id2.kind !== "litString") {
+            throw new CompileError(
+              "Bound row id must be a string literal.",
+              id2.pos
+            );
+          }
+          if (id2.value.length === 0) {
+            throw new CompileError("Bound row id must not be empty.", id2.pos);
+          }
+          if (row2.typeArguments !== void 0) {
+            if (row2.typeArguments.length !== 1) {
+              throw new CompileError(
+                "Reference requires exactly one generic target type.",
+                row2.pos
+              );
+            }
+            this.requireAssignable(
+              this.resolveType(row2.typeArguments[0]),
+              variantInfo2.valueType,
+              row2.pos,
+              "Lookup variant row"
+            );
+          }
+          const rowType = this.context.persistedReferenceTypes?.get(id2.value);
+          if (rowType !== void 0) {
+            this.requireAssignable(
+              neoScriptReadType(rowType),
+              variantInfo2.valueType,
+              row2.pos,
+              "Lookup variant row"
+            );
+          }
+          const bound = this.project.typeByName.get(NEO_VARIANT_TYPE_NAME);
+          if (bound === void 0) {
+            throw new CompileError(
+              `The seeded '${NEO_VARIANT_TYPE_NAME}' class is missing.`,
+              pos
+            );
+          }
+          return {
+            pointer: { ...receiver.pointer, rowValueId: id2.value },
+            type: {
+              kind: "named",
+              typeId: bound.id,
+              typeArguments: receiver.type.kind === "named" ? receiver.type.typeArguments?.slice(0, 1) ?? [] : []
+            }
+          };
+        }
         if (isInitialize) {
           const variantInfo2 = this.variantTypeInfo(receiver.type);
           if (variantInfo2 === null) return null;
@@ -75641,6 +75859,8 @@ var init_strict_resolver = __esm({
           }
           const staticType = this.project.typeByName.get(receiverAst.name);
           if (staticType && staticType.kind !== "enum") {
+            if (receiverAst.typeQualifier)
+              this.resolveType(receiverAst.typeQualifier);
             this.assertUserSafe(
               { kind: "named", typeId: staticType.id },
               "a static receiver",
@@ -75780,6 +76000,9 @@ var init_strict_resolver = __esm({
             pointer: listIndexPointer(receiver.pointer, index),
             type: viewType,
             writability: "readOnly" /* ReadOnly */,
+            ...receiver.entryWritability !== void 0 ? { entryWritability: receiver.entryWritability } : {},
+            entryUserData: receiver.entryUserData === true,
+            ...receiver.writeRoot !== void 0 ? { writeRoot: receiver.writeRoot } : {},
             indexDefinition: index,
             indexCollectionPointer: receiver.pointer
           };
@@ -75788,7 +76011,10 @@ var init_strict_resolver = __esm({
           return {
             pointer: receiver.pointer,
             type: { kind: "primitive", name: "unknown" },
-            indexSurface: receiver.type
+            indexSurface: receiver.type,
+            entryWritability: receiver.entryWritability ?? receiver.writability ?? "runtime" /* Runtime */,
+            entryUserData: receiver.entryWritability === void 0 ? receiver.userData === true : receiver.entryUserData === true,
+            writeRoot: this.expressionWriteRoot(receiver, scope)
           };
         }
         if ((name === "Keys" || name === "Values") && receiver.type.kind === "dictionary") {
@@ -76063,7 +76289,7 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        if (entry.id.startsWith(NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX)) {
+        if (entry.id.startsWith(NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX) && !this.options.allowPendingRegistryEntries) {
           throw new CompileError(
             `${registry.entryType} '${name}' has no @id, so it has never been pushed and has no project file to reference. Push the file before referencing it.`,
             pos
@@ -76191,7 +76417,10 @@ var init_strict_resolver = __esm({
               key.pointer
             ),
             type: resultType,
-            writability: "readOnly" /* ReadOnly */
+            writability: "readOnly" /* ReadOnly */,
+            ...receiver.entryWritability !== void 0 ? { entryWritability: receiver.entryWritability } : {},
+            entryUserData: receiver.entryUserData === true,
+            ...receiver.writeRoot !== void 0 ? { writeRoot: receiver.writeRoot } : {}
           };
         }
         const readonlyCollection = receiver.symbol?.readonlyDeclaration === true && receiver.initWritability !== void 0 ? {
@@ -76864,6 +77093,33 @@ var init_strict_resolver = __esm({
             typeArguments
           );
         }
+        if (callee.kind === "lambda" && expected !== void 0) {
+          rejectTypeArguments();
+          const parameterTypes = callee.params.map((parameter4) => {
+            if (parameter4.type === null) {
+              throw new CompileError(
+                "An immediately invoked lambda requires explicit parameter types.",
+                parameter4.pos
+              );
+            }
+            return this.resolveType(parameter4.type);
+          });
+          return this.resolveDelegateCall(
+            this.resolveDelegateLambda(
+              callee,
+              {
+                kind: "delegate",
+                parameterTypes,
+                returnType: expected
+              },
+              scope
+            ),
+            argumentsList2,
+            scope,
+            pos,
+            false
+          );
+        }
         const variantCall = this.resolveVariantCall(
           callee,
           argumentsList2,
@@ -77027,6 +77283,8 @@ var init_strict_resolver = __esm({
           }
           const staticType = this.project.typeByName.get(callee.receiver.name);
           if (staticType && staticType.kind !== "enum") {
+            if (callee.receiver.typeQualifier)
+              this.resolveType(callee.receiver.typeQualifier);
             this.assertUserSafe(
               { kind: "named", typeId: staticType.id },
               "a static receiver",
@@ -85628,7 +85886,10 @@ function formatNeoScript(text, options = {}) {
   const literalNewlines = /* @__PURE__ */ new Set();
   const delimiterTokensByLine = /* @__PURE__ */ new Map();
   const tokensByLine = /* @__PURE__ */ new Map();
-  const lambdaBraceOffsets = /* @__PURE__ */ new Set();
+  const braceHeaderLines = /* @__PURE__ */ new Map();
+  const parenthesisLines = [];
+  const genericLines = [];
+  let previousHeaderLine = 0;
   const genericOffsets = genericAngleOffsets(syntax.lexed.tokens);
   const continuationOperator = (token) => !genericOffsets.has(token.start) && isContinuationOperator(token);
   let annotationState = "none";
@@ -85664,9 +85925,22 @@ function formatNeoScript(text, options = {}) {
         tripleString = { token, previous: previousSignificantToken };
     }
     if (token.kind !== "comment" && token.kind !== "eof") {
-      if (token.kind === "punctuation" && token.text === "{" && previousSignificantToken?.kind === "operator" && previousSignificantToken.text === "=>") {
-        lambdaBraceOffsets.add(token.start);
-      }
+      let headerLine = token.range.start.line;
+      const followsTypeOrName = previousSignificantToken?.kind === "identifier" || previousSignificantToken?.text === "new" || previousSignificantToken?.text === ">" && genericOffsets.has(previousSignificantToken.start);
+      if (token.kind === "identifier" && previousSignificantToken?.text === "new" || token.text === "(" && followsTypeOrName)
+        headerLine = previousHeaderLine;
+      if (genericOffsets.has(token.start)) {
+        if (token.text === "<") genericLines.push(previousHeaderLine);
+        if (token.text === ">") headerLine = genericLines.pop() ?? headerLine;
+      }
+      if (token.text === "(") parenthesisLines.push(headerLine);
+      if (token.text === ")") headerLine = parenthesisLines.pop() ?? headerLine;
+      if (token.text === "{")
+        braceHeaderLines.set(
+          token.start,
+          previousSignificantToken?.text === ")" || previousSignificantToken?.text === "=>" || previousSignificantToken?.kind === "identifier" || previousSignificantToken?.text === ">" && genericOffsets.has(previousSignificantToken.start) ? previousHeaderLine : headerLine
+        );
+      previousHeaderLine = headerLine;
       let annotationEnd = false;
       if (token.kind === "punctuation" && token.text === "@" && annotationDepth === 0)
         annotationState = "name";
@@ -85695,6 +85969,8 @@ function formatNeoScript(text, options = {}) {
   }
   const formatted = [];
   const delimiters = [];
+  const lineDepths = /* @__PURE__ */ new Map();
+  const braceHeaderDepth = (token) => lineDepths.get(braceHeaderLines.get(token.start) ?? -1);
   const continuations = /* @__PURE__ */ new Set();
   let preceding;
   let aligning;
@@ -85728,14 +86004,21 @@ function formatNeoScript(text, options = {}) {
     const sectionDepth = switchSectionIndentDepth(syntax.parsed, contentOffset);
     const leadingState = cloneDelimiterStack(delimiters);
     for (const token of leadingClosers) {
-      applyDelimiterToken(leadingState, token, lambdaBraceOffsets);
+      applyDelimiterToken(leadingState, token);
     }
-    const depth = delimiterDepth(leadingState);
+    let depth = delimiterDepth(leadingState);
     const significant = tokensByLine.get(lineIndex) ?? [];
-    pruneContinuations(continuations, leadingState);
+    lineDepths.set(lineIndex, depth);
     const first = significant[0];
+    const continuationScope = leadingState.at(-1)?.openingOffset ?? -1;
+    if (first?.text === "{") {
+      applyDelimiterToken(leadingState, first, braceHeaderDepth(first));
+      depth = delimiterDepth(leadingState) - 1;
+      lineDepths.set(lineIndex, depth);
+    }
+    pruneContinuations(continuations, leadingState);
     if (leadingClosers.length === 0 && (first !== void 0 && continuationOperator(first) && preceding !== void 0 && canEndExpression(preceding) || preceding !== void 0 && continuationOperator(preceding)))
-      continuations.add(leadingState.at(-1)?.openingOffset ?? -1);
+      continuations.add(continuationScope);
     const lineDepth = depth + sectionDepth + continuations.size;
     const normalized = first?.range.start.character === firstContentCharacter ? normalizeControlHeaderSpacing(content) : content;
     const indent2 = indentUnit.repeat(lineDepth);
@@ -85746,7 +86029,7 @@ function formatNeoScript(text, options = {}) {
     if (standalone !== void 0 && standalone.closingIndent !== indent2)
       aligning = { ...standalone, indent: indent2 };
     for (const token of lineTokens) {
-      applyDelimiterToken(delimiters, token, lambdaBraceOffsets);
+      applyDelimiterToken(delimiters, token, braceHeaderDepth(token));
     }
     pruneContinuations(continuations, delimiters);
     const last = significant.at(-1);
@@ -85887,25 +86170,26 @@ function leadingClosingTokens(lineTokens, firstContentCharacter) {
   }
   return result;
 }
-function applyDelimiterToken(stack, token, lambdaBraceOffsets) {
+function applyDelimiterToken(stack, token, headerDepth) {
   if (isOpeningDelimiter(token.text)) {
-    let restores;
-    if (token.text === "{" && lambdaBraceOffsets.has(token.start)) {
-      for (let index = stack.length - 1; index >= 0; index--) {
+    const restores = [];
+    if (token.text === "{" && headerDepth !== void 0) {
+      let depth = delimiterDepth(stack);
+      for (let index = stack.length - 1; index >= 0 && depth > headerDepth; index--) {
         const candidate = stack[index];
-        if (candidate?.text === "(" && candidate.contributes && candidate.openingLine === token.range.start.line) {
-          restores = candidate;
-          break;
+        if (candidate?.text === "{") break;
+        if (candidate?.text === "(" && candidate.contributes) {
+          restores.push(candidate);
+          candidate.contributes = false;
+          depth--;
         }
       }
-      if (restores) restores.contributes = false;
     }
     stack.push({
       text: token.text,
-      openingLine: token.range.start.line,
       openingOffset: token.start,
       contributes: true,
-      ...restores ? { restores } : {}
+      ...restores.length > 0 ? { restores } : {}
     });
     return;
   }
@@ -85919,7 +86203,7 @@ function applyDelimiterToken(stack, token, lambdaBraceOffsets) {
   }
   if (frameIndex < 0) return;
   const [frame] = stack.splice(frameIndex, 1);
-  if (frame?.restores) frame.restores.contributes = true;
+  for (const restored of frame?.restores ?? []) restored.contributes = true;
 }
 function pruneContinuations(continuations, stack) {
   const scopes = /* @__PURE__ */ new Set([-1, ...stack.map((frame) => frame.openingOffset)]);
@@ -85930,20 +86214,11 @@ function delimiterDepth(stack) {
   return stack.filter((frame) => frame.contributes).length;
 }
 function cloneDelimiterStack(stack) {
-  const clones = stack.map((frame) => ({
+  return stack.map((frame) => ({
     text: frame.text,
-    openingLine: frame.openingLine,
     openingOffset: frame.openingOffset,
     contributes: frame.contributes
   }));
-  for (let index = 0; index < stack.length; index++) {
-    const restores = stack[index]?.restores;
-    if (!restores) continue;
-    const restoreIndex = stack.indexOf(restores);
-    if (restoreIndex < 0) continue;
-    clones[index] = { ...clones[index], restores: clones[restoreIndex] };
-  }
-  return clones;
 }
 function matchingOpeningDelimiter(value) {
   switch (value) {
@@ -90590,7 +90865,7 @@ var init_neoscript_language_context_adapter = __esm({
     init_dialogue_types();
     init_dialogue_group_language();
     init_analyzer_types();
-    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 6;
+    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 7;
     UNKNOWN_TYPE2 = {
       kind: "primitive",
       name: "unknown"
@@ -91227,6 +91502,7 @@ function compileMemberInitializerBody(args) {
   const returnTypeInfo = resolveMemberDeclaredTypeInfo(
     args.member,
     members2,
+    args.classes,
     args.thisClass
   );
   if (returnTypeInfo === null) {
@@ -91274,7 +91550,8 @@ function compileValueRowInitializerBody(args) {
   }
   const returnTypeInfo = resolveMemberDeclaredTypeInfo(
     args.member,
-    args.members
+    args.members,
+    args.classes
   );
   if (returnTypeInfo === null) {
     throw new Error(
@@ -91457,6 +91734,7 @@ function compileConstructorBaseInitializerFields(args, owner) {
     const declaredTypeInfo = resolveMemberDeclaredTypeInfo(
       member,
       args.members,
+      args.classes,
       args.classes.find(
         (schemaClass2) => schemaClass2.id === entry.ownerClassId
       ) ?? null
@@ -97695,7 +97973,11 @@ function validateMember(uri, member, ownerName, documentKind, ownerScope, enviro
       member.initializer.text,
       memberType2,
       scope,
-      member.modifiers.includes("static") ? { ...environment, staticMember: true } : environment,
+      {
+        ...environment,
+        staticMember: member.modifiers.includes("static"),
+        checkComputedInitializers: true
+      },
       member.initializer.range,
       diagnostics,
       anchorOf(member.initializer),
@@ -98619,6 +98901,80 @@ function knownGeneratorExpression(expression, scope, environment) {
   return candidates !== void 0 && candidates.length > 0 && candidates.every((member) => member.generator === true);
 }
 function validateExpression(expression, expected, scope, environment, uri, range2, diagnostics, anchor, storedValue = true) {
+  const sourceOnly = expected !== void 0 && (isNeoVariantTypeName(expected.name) || expected.name === "NeoAction" || expected.name === "ImageRef");
+  let receiver = expression;
+  if (environment.checkComputedInitializers) {
+    while (receiver.kind === "member") receiver = receiver.receiver;
+  }
+  const computed = environment.checkComputedInitializers && !sourceOnly && (expression.kind === "member" && (receiver.kind !== "ident" || receiver.typeQualifier !== void 0) || [
+    "binary",
+    "unary",
+    "force",
+    "coalesce",
+    "conditional",
+    "switchExpression",
+    "is",
+    "lambda",
+    "index",
+    "litInterp",
+    "litTripleString",
+    "call"
+  ].includes(expression.kind)) && !isReferenceCall(expression);
+  const count = diagnostics.length;
+  validateStoredExpression(
+    expression,
+    expected,
+    scope,
+    computed || sourceOnly || expression.kind === "member" ? { ...environment, checkComputedInitializers: false } : environment,
+    uri,
+    range2,
+    diagnostics,
+    anchor,
+    storedValue
+  );
+  if (!computed || diagnostics.length !== count) return;
+  const { context, resolver, parameterNames, parameterTypes } = initializerResolver(
+    environment,
+    scope.get("this")?.name ?? "",
+    environment.staticMember,
+    "initializer"
+  );
+  try {
+    const reads = new Set(
+      collectIdentifierReads(expression, parameterNames).map(
+        (read) => read.name
+      )
+    );
+    const parameters = [...reads].map((name) => ({
+      name,
+      type: parameterTypes.get(name)
+    }));
+    const scopedResolver = parameters.length === 0 ? resolver : new StrictNeoScriptResolver(
+      { ...context, parameters },
+      environment.projectIndex,
+      void 0,
+      { allowPendingRegistryEntries: true }
+    );
+    scopedResolver.validateInitializerExpression(
+      expression,
+      expected === void 0 ? void 0 : resolveNeoScriptType(
+        semanticAst(expected, expression.pos),
+        context,
+        environment.projectIndex
+      )
+    );
+  } catch (error) {
+    if (!(error instanceof CompileError)) throw error;
+    pushDiagnostic(
+      diagnostics,
+      uri,
+      anchor ? anchorSpan(anchor, error, 1) : range2,
+      "invalid-computed-initializer",
+      error.message.replace(/^\d+:\d+: /, "")
+    );
+  }
+}
+function validateStoredExpression(expression, expected, scope, environment, uri, range2, diagnostics, anchor, storedValue = true) {
   if (anchor !== void 0 && expression.kind === "call") {
     const error = sourceCallBinding(expression, scope, environment)?.error;
     if (error?.message.includes(
@@ -98843,7 +99199,7 @@ function validateExpression(expression, expected, scope, environment, uri, range
         // Enum dictionaries also preserve quoted option IDs, including orphaned IDs.
         entry.key.kind === "litString" ? void 0 : key,
         scope,
-        environment,
+        { ...environment, checkComputedInitializers: false },
         uri,
         range2,
         diagnostics,
@@ -99025,6 +99381,17 @@ function validateExpression(expression, expected, scope, environment, uri, range
   }
   if (expression.kind === "new") {
     const typeName = expression.className ?? expected?.name;
+    if (typeName === "List" || typeName === "Set" || typeName === "Dictionary") {
+      const literal3 = typeName === "Dictionary" ? "{}" : "[]";
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        anchor ? anchorSpan(anchor, expression.pos, 3) : range2,
+        "collection-construction",
+        `${typeName} has no constructor. Use ${literal3} for an empty collection.`
+      );
+      return;
+    }
     const declaration = typeName ? environment.types.get(typeName) : void 0;
     for (const entry of expression.initializer ?? []) {
       if (entry.name !== "layerClassId") continue;
@@ -99958,24 +100325,49 @@ function wrappedTypeParameterConstruction(declaration, typeArguments, scope, env
   }
   return target.kind === "named" ? wrappedTypeParameterMessage(target, environment.projectIndex) : null;
 }
-function initializerResolver(environment, thisName, staticMember) {
+function initializerResolver(environment, thisName, staticMember, kind = "initializerExpression") {
   const declaring = environment.projectIndex.typeByName.get(thisName);
-  const key = `${declaring?.id ?? ""}:${staticMember}`;
+  const key = `${declaring?.id ?? ""}:${staticMember}:${kind}`;
   let entry = environment.initializerResolvers.get(key);
   if (entry === void 0) {
     const declaringType = declaring ? { kind: "named", typeId: declaring.id } : void 0;
     const context = {
       project: environment.project,
-      kind: "initializerExpression",
+      kind,
       ...declaringType ? {
         declaringType,
         implicitMemberAccess: true,
         ...staticMember ? { staticMember } : { thisClass: declaringType }
       } : {}
     };
+    const parameterTypes = /* @__PURE__ */ new Map();
+    if (kind === "initializer" && !staticMember) {
+      const owner = environment.types.get(thisName);
+      for (const parameter4 of owner?.headerParameters ?? []) {
+        try {
+          parameterTypes.set(
+            parameter4.name,
+            resolveNeoScriptType(
+              semanticAst(semanticType(parameter4.type), { line: 1, column: 1 }),
+              context,
+              environment.projectIndex
+            )
+          );
+        } catch (error) {
+          if (!(error instanceof CompileError)) throw error;
+        }
+      }
+    }
     entry = {
       context,
-      resolver: new StrictNeoScriptResolver(context, environment.projectIndex)
+      parameterNames: new Set(parameterTypes.keys()),
+      parameterTypes,
+      resolver: new StrictNeoScriptResolver(
+        context,
+        environment.projectIndex,
+        void 0,
+        { allowPendingRegistryEntries: true }
+      )
     };
     environment.initializerResolvers.set(key, entry);
   }
@@ -100525,7 +100917,7 @@ function validatePlaceReference(expression, expected, thisName, environment, rep
     environment.staticMember
   );
   try {
-    resolver.resolvePersistedReference(
+    resolver.validateInitializerExpression(
       expression,
       expected === void 0 ? void 0 : resolveNeoScriptType(
         semanticAst(expected, expression.pos),
@@ -101817,6 +102209,29 @@ function buildProjectGraph(documents) {
     rootType
   ];
   const globals = [];
+  const variants = [];
+  for (const entries of buildNeoVariantScopeIndex(
+    documents
+  ).variantsByScope.values()) {
+    for (const entry of entries) {
+      const classId = graph.typeIdsByName.byName.get(entry.className);
+      if (classId === void 0) continue;
+      const folder = entry.scope.slice(`${entry.className}.${NEO_VARIANT_SCOPE_NAME}`.length + 1).split(".").join("/");
+      const valueType = entry.declaration.type.typeArguments[1];
+      const valueTypeId = valueType === void 0 ? void 0 : graph.typeIdsByName.byName.get(valueType.name);
+      variants.push({
+        id: sourceIdentity2(
+          entry.declaration.annotations,
+          `variant:${entry.uri}:${entry.className}:${entry.scope}:${entry.name}`
+        ),
+        classId,
+        name: entry.name,
+        folder: folder.length === 0 ? null : folder,
+        ...valueTypeId === void 0 ? {} : { valueTypeId },
+        location: location(entry.uri, entry.declaration.nameRange)
+      });
+    }
+  }
   const extensions = [];
   const memberInfo = new Map(graph.memberInfo);
   const roots = [];
@@ -101870,7 +102285,7 @@ function buildProjectGraph(documents) {
   return {
     ...graph,
     memberInfo,
-    project: { ...graph.project, types, globals, roots, extensions }
+    project: { ...graph.project, types, globals, roots, extensions, variants }
   };
 }
 function buildDeclarationGraph(documents) {
@@ -102859,6 +103274,7 @@ var init_project_source_script_compiler = __esm({
     init_project_root();
     init_function_overload_identity();
     init_project_source_registry();
+    init_project_source_variants();
     init_compilation_product();
     init_runtime_source();
     init_lexer();
@@ -123898,6 +124314,14 @@ function isNamePath(expression) {
   return expression.kind === "member" && isNamePath(expression.receiver);
 }
 function isLiteralCall(expression) {
+  if (expression.callee.kind === "member" && expression.callee.name === "Bind") {
+    let receiver = expression.callee.receiver;
+    while (receiver.kind === "member") {
+      if (receiver.name === "Variants" && isNamePath(receiver.receiver))
+        return true;
+      receiver = receiver.receiver;
+    }
+  }
   if (expression.callee.kind === "ident" && expression.callee.name === "Reference") {
     if (expression.argumentNames?.some((name) => name !== null)) return true;
     const [place] = expression.args;
@@ -128101,7 +128525,8 @@ function lowerBindings(context, ownerClass, ownerParameters, ownerRecordId, para
       continue;
     }
     const baseBinding = baseArguments?.[parameterId];
-    const memberId = baseBinding?.kind === "member" ? baseBinding.memberId : derivedGenericArgumentMemberId(ownerRecordId, parameterId);
+    const derive = isPendingId(ownerRecordId) || isPendingId(parameterId) ? pendingGenericArgumentMemberId : derivedGenericArgumentMemberId;
+    const memberId = baseBinding?.kind === "member" ? baseBinding.memberId : derive(ownerRecordId, parameterId);
     result[parameterId] = { kind: "member", memberId };
     lowerGenericArgument(
       context,
@@ -128755,6 +129180,7 @@ var init_lower_members = __esm({
     init_ui_action_source();
     init_entry_member_id();
     init_generic_argument_member_id();
+    init_pending_id();
     init_structured_leaf_source();
     init_member_kind_type_names();
     init_set_literal_duplicates();
@@ -135236,6 +135662,59 @@ var init_dialogue_lower = __esm({
   }
 });
 
+// src/project-source/identity-rewriter.ts
+function createIdentityRewriter(assignments, onReplace) {
+  if (assignments.size === 0) return (value) => value;
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const [source, replacement] of assignments) {
+    let prefix = root;
+    for (let index = 0; index < source.length; index += 1) {
+      const character = source[index];
+      let child2 = prefix.children.get(character);
+      if (child2 === void 0) {
+        child2 = { children: /* @__PURE__ */ new Map() };
+        prefix.children.set(character, child2);
+      }
+      prefix = child2;
+    }
+    prefix.replacement = replacement;
+  }
+  return (value) => {
+    const exact = assignments.get(value);
+    if (exact !== void 0) {
+      onReplace?.(value);
+      return exact;
+    }
+    const parts = [];
+    let copiedThrough = 0;
+    for (let start = 0; start < value.length; start += 1) {
+      let prefix = root.children.get(value[start]);
+      let replacement;
+      let end = start;
+      for (let index = start; prefix !== void 0; index += 1) {
+        if (prefix.replacement !== void 0) {
+          replacement = prefix.replacement;
+          end = index + 1;
+        }
+        prefix = prefix.children.get(value[index + 1]);
+      }
+      if (replacement === void 0) continue;
+      onReplace?.(value.slice(start, end));
+      parts.push(value.slice(copiedThrough, start), replacement);
+      copiedThrough = end;
+      start = end - 1;
+    }
+    if (copiedThrough === 0) return value;
+    parts.push(value.slice(copiedThrough));
+    return parts.join("");
+  };
+}
+var init_identity_rewriter = __esm({
+  "src/project-source/identity-rewriter.ts"() {
+    "use strict";
+  }
+});
+
 // ../src/database/document-initializer-compiler.ts
 function initializerCompilerState(document, compilationProject) {
   const existing = documentInitializerCompilerStates.get(document);
@@ -135260,7 +135739,9 @@ function compilationProjectForDocument(document, state) {
     classes: document.classes,
     enums: document.enums,
     interfaces: document.interfaces,
-    constructors: document.constructors ?? []
+    constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? []
   });
   return state.compilationProject;
 }
@@ -135359,6 +135840,8 @@ function compileValueInitializerDependency(document, valueId, compilationProject
     enums: document.enums,
     interfaces: document.interfaces,
     constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? [],
     member: site.member,
     valueRow: { ...site.row },
     valueId: site.row.id,
@@ -135377,7 +135860,9 @@ function compileMemberInitializerDependency(document, memberId, compilationProje
     classes: document.classes,
     enums: document.enums,
     interfaces: document.interfaces,
-    constructors: document.constructors ?? []
+    constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? []
   };
   const memberIndex = documentMemberCompilationIndex(document);
   const member = memberIndex.membersById.get(memberId);
@@ -145933,6 +146418,7 @@ function appendAuthoredOwnedValueCascadeDeletes(args) {
     while (parentId != null && !visited.has(parentId)) {
       visited.add(parentId);
       const parent = postValuesById.get(parentId);
+      if (isInitValueContent(parent)) break;
       if (parent !== void 0 && isLiteralValueContent(parent) && isVirtualInstanceRootShape(parent) && postPlacements.has(parentId)) {
         survivingConstructionIds.add(parentId);
         break;
@@ -146643,6 +147129,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     appendConstructionTypes
   });
   materializePreparedInstanceInitializers({
+    referenceOwners: args.initializerReferenceOwners,
     document: args.document,
     physicalValues: args.document.physicalValues,
     prepared,
@@ -146994,7 +147481,8 @@ function materializePreparedInstanceInitializers(args) {
   if (pendingInitializerIds.size === 0) return;
   const batch = createInitializerMaterializationBatch(
     materializationScope.document,
-    pendingInitializerIds
+    pendingInitializerIds,
+    args.referenceOwners
   );
   materializeInitializerDependencies(pendingInitializerIds, (valueId) => {
     const site = pendingSites.get(valueId);
@@ -149178,6 +149666,8 @@ function compileOwnedValueRowInitializer(args) {
     enums: document.enums,
     interfaces: document.interfaces,
     constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? [],
     compilationProject: args.compilationProject,
     member,
     valueRow: row,
@@ -149243,7 +149733,9 @@ function prepareServerOwnedValueInitializerBodies(args) {
       classes: document.classes,
       enums: document.enums,
       interfaces: document.interfaces,
-      constructors: document.constructors ?? []
+      constructors: document.constructors ?? [],
+      variants: document.variants ?? [],
+      variantFolders: document.variantFolders ?? []
     });
     compilationProjects.set(document, compilationProject);
     return compilationProject;
@@ -152904,12 +153396,12 @@ function assertNoVariantTypePositions(args) {
   for (const declaredConstructor of args.constructors ?? []) {
     const ids = [];
     for (const argument2 of declaredConstructor.argumentTypes ?? []) {
-      typeInfoClassIds(argument2, ids, args.classesById);
+      typeInfoClassIds(argument2, ids, args.classesById, true);
     }
     for (const classId of ids) {
       if (!isVariantFamilyClassId(classId, args.classesById)) continue;
       throw new Error(
-        `Constructor "${declaredConstructor.id}" declares a parameter of ${variantFamilyLabel(classId, args.classesById)}, which is reference-only: a variant is named by a Variant member, never passed as a value.`
+        `Constructor "${declaredConstructor.id}" declares a parameter of ${variantFamilyLabel(classId, args.classesById)}, which cannot be used as a constructor argument type.`
       );
     }
   }
@@ -158262,7 +158754,10 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
   const variantMembers = projected.members.filter(
     (member) => member.kind === 27 /* Variant */
   );
-  if (variantMembers.length === 0) return;
+  if (variantMembers.length === 0 && !projected.values.some(
+    (row) => isLiteralValueContent(row) && row.constructorArgs != null
+  ))
+    return;
   const classesById = new Map(
     projected.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
@@ -158340,6 +158835,46 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
       });
     }
   }
+  let constructorGraph;
+  for (const row of projected.values) {
+    if (!isLiteralValueContent(row) || row.constructorArgs == null) continue;
+    constructorGraph ??= new MaterializedValueGraphContext(
+      projected,
+      valuesById
+    );
+    for (const [
+      parameterId,
+      typeInfo
+    ] of constructorGraph.constructorParameterTypes(row)) {
+      if (typeInfo.type !== 7 /* Class */) continue;
+      const systemClass = classesById.get(typeInfo.classId);
+      const worldKind = systemClass?.system?.worldKind;
+      if (worldKind !== NeoWorldSystemClassKind.Variant && worldKind !== NeoWorldSystemClassKind.LookupVariant)
+        continue;
+      const label = `Constructor argument "${parameterId}" of row "${row.id}"`;
+      const targetParamId = systemClass?.genericParams?.[0]?.id;
+      const targetTypeInfo = targetParamId === void 0 ? void 0 : typeInfo.typeArguments?.[targetParamId];
+      if (targetTypeInfo === void 0)
+        throw new Error(`${label} declares no variant target type.`);
+      const valueParamId = systemClass?.genericParams?.[1]?.id;
+      const valueTypeInfo = valueParamId === void 0 ? void 0 : typeInfo.typeArguments?.[valueParamId];
+      if (worldKind === NeoWorldSystemClassKind.LookupVariant && valueTypeInfo === void 0)
+        throw new Error(`${label} declares no lookup value type.`);
+      const declaration = {
+        kind: 27 /* Variant */,
+        name: parameterId,
+        targetTypeInfo,
+        ...valueTypeInfo === void 0 ? {} : { valueTypeInfo },
+        ...typeInfo.required ? { requirement: 1 /* Required */ } : {}
+      };
+      assertVariantMemberTargetValid({ declaration, label, classesById });
+      graded.push({
+        value: row.constructorArgs[parameterId],
+        declaration,
+        label
+      });
+    }
+  }
   for (const entry of graded) {
     assertVariantReferenceValid({
       value: entry.value,
@@ -158640,7 +159175,14 @@ var init_project_version_whole_graph_validation = __esm({
       25 /* NSDelegate */,
       26 /* NSAction */
     ]);
-    VARIANT_MEMBER_TRIGGER_RECORD_KINDS = /* @__PURE__ */ new Set(["member", "class", "value", "variant"]);
+    VARIANT_MEMBER_TRIGGER_RECORD_KINDS = /* @__PURE__ */ new Set([
+      "member",
+      "class",
+      "constructor",
+      "value",
+      "variant",
+      "variant-folder"
+    ]);
   }
 });
 
@@ -158720,6 +159262,7 @@ function preparationArgs(context) {
   const { args } = context;
   return {
     document: context.document,
+    initializerReferenceOwners: args.initializerReferenceOwners,
     contentHashHeads: context.contentHashHeads,
     changes: args.changes,
     authoredValueSeeds: args.authoredValueSeeds,
@@ -159215,59 +159758,6 @@ var init_client_commit_preparation = __esm({
   }
 });
 
-// src/project-source/identity-rewriter.ts
-function createIdentityRewriter(assignments, onReplace) {
-  if (assignments.size === 0) return (value) => value;
-  const root = { children: /* @__PURE__ */ new Map() };
-  for (const [source, replacement] of assignments) {
-    let prefix = root;
-    for (let index = 0; index < source.length; index += 1) {
-      const character = source[index];
-      let child2 = prefix.children.get(character);
-      if (child2 === void 0) {
-        child2 = { children: /* @__PURE__ */ new Map() };
-        prefix.children.set(character, child2);
-      }
-      prefix = child2;
-    }
-    prefix.replacement = replacement;
-  }
-  return (value) => {
-    const exact = assignments.get(value);
-    if (exact !== void 0) {
-      onReplace?.(value);
-      return exact;
-    }
-    const parts = [];
-    let copiedThrough = 0;
-    for (let start = 0; start < value.length; start += 1) {
-      let prefix = root.children.get(value[start]);
-      let replacement;
-      let end = start;
-      for (let index = start; prefix !== void 0; index += 1) {
-        if (prefix.replacement !== void 0) {
-          replacement = prefix.replacement;
-          end = index + 1;
-        }
-        prefix = prefix.children.get(value[index + 1]);
-      }
-      if (replacement === void 0) continue;
-      onReplace?.(value.slice(start, end));
-      parts.push(value.slice(copiedThrough, start), replacement);
-      copiedThrough = end;
-      start = end - 1;
-    }
-    if (copiedThrough === 0) return value;
-    parts.push(value.slice(copiedThrough));
-    return parts.join("");
-  };
-}
-var init_identity_rewriter = __esm({
-  "src/project-source/identity-rewriter.ts"() {
-    "use strict";
-  }
-});
-
 // src/project-source/trusted-commit-verification.ts
 function verifyProjectSourceCommitAgainstStateV4(args) {
   const root = "/neo-source-verify-virtual";
@@ -159466,6 +159956,21 @@ function validateAssignments(value) {
   return assignments;
 }
 function derivedAssignment(pendingId2) {
+  const genericArgument = pendingGenericArgumentIdentity(pendingId2);
+  if (genericArgument !== null)
+    return {
+      ownerLocator: genericArgument.parentRecordId,
+      derive: (parent, assignments) => {
+        const parameter4 = isPendingId(genericArgument.genericParamId) ? assignments.get(genericArgument.genericParamId) : genericArgument.genericParamId;
+        if (parameter4 === void 0)
+          throw new ProjectSourceCommitVerificationError(
+            `Generic argument assignment ${pendingId2} names parameter ${genericArgument.genericParamId}, which has no pending id assignment.`
+          );
+        return derivedGenericArgumentMemberId(parent, parameter4);
+      },
+      label: "Generic argument assignment",
+      ownerNoun: "binding owner"
+    };
   const tupleElement = pendingTupleElementIdentity(pendingId2);
   if (tupleElement !== null)
     return {
@@ -159564,6 +160069,15 @@ function relocatedAssignment(pendingId2, assignments, byPosition, used) {
   const key = positionIndependentPendingKey(pendingId2);
   const relocated = key === null ? void 0 : byPosition.get(key);
   if (relocated !== void 0) return relocated;
+  const genericArgument = pendingGenericArgumentIdentity(pendingId2);
+  if (genericArgument !== null) {
+    const relocate = (id2) => !isPendingId(id2) || assignments.has(id2) ? id2 : relocatedAssignment(id2, assignments, byPosition, used);
+    const parent = relocate(genericArgument.parentRecordId);
+    const parameter4 = relocate(genericArgument.genericParamId);
+    if (parent === null || parameter4 === null) return null;
+    const rebuilt = pendingGenericArgumentMemberId(parent, parameter4);
+    return assignments.has(rebuilt) ? rebuilt : null;
+  }
   for (const [owner, rebuild] of [
     [pendingMemberValueMemberId(pendingId2), pendingMemberValueId],
     [pendingEntryMemberDeclaringId(pendingId2), pendingEntryMemberId],
@@ -159896,6 +160410,7 @@ var init_trusted_commit_verification = __esm({
     "use strict";
     init_tuple_element_member_id();
     init_identity_rewriter();
+    init_generic_argument_member_id();
     init_lower_support();
     init_schema_source_validation();
     init_projectRecordBuckets();
@@ -159969,6 +160484,7 @@ function sourceCommitPreparation(args) {
       timestamp: args.serverTimestamp
     }),
     authoredValueSeeds: args.authoredValueSeeds,
+    initializerReferenceOwners: args.initializerReferenceOwners,
     forceRecompile: args.forceRecompile,
     scriptSources: args.scriptSources,
     serverTimestamp: args.serverTimestamp
@@ -160156,7 +160672,9 @@ function replayStoredConstructionV4(args) {
     classes: document.classes,
     enums: document.enums,
     interfaces: document.interfaces,
-    constructors: document.constructors ?? []
+    constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? []
   }) : void 0);
   if (args.compileDocumentBodies === true) {
     if (compilationProject === void 0) {
@@ -160205,6 +160723,8 @@ function replayStoredConstructionV4(args) {
       enums: document.enums,
       interfaces: document.interfaces,
       constructors: document.constructors,
+      variants: document.variants ?? [],
+      variantFolders: document.variantFolders ?? [],
       member: compileMember,
       valueRow: candidate,
       valueId: args.valueId,
@@ -160276,7 +160796,9 @@ function compilePulledUncompiledConstructorsV4(document, compilationProject, rep
     classes: document.classes,
     enums: document.enums,
     interfaces: document.interfaces,
-    constructors: document.constructors ?? []
+    constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? []
   });
   const compileArgs = {
     project: document.project,
@@ -160287,6 +160809,8 @@ function compilePulledUncompiledConstructorsV4(document, compilationProject, rep
     enums: document.enums,
     interfaces: document.interfaces,
     constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? [],
     compilationProject: project
   };
   for (const constructor2 of uncompiled) {
@@ -160310,7 +160834,9 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
     classes: document.classes,
     enums: document.enums,
     interfaces: document.interfaces,
-    constructors: document.constructors ?? []
+    constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? []
   });
   documentInitializerCompiler(document, sharedCompilationProject);
   const compileArgs = {
@@ -160322,6 +160848,8 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
     enums: document.enums,
     interfaces: document.interfaces,
     constructors: document.constructors ?? [],
+    variants: document.variants ?? [],
+    variantFolders: document.variantFolders ?? [],
     compilationProject: sharedCompilationProject
   };
   const constructors = document.constructors ?? [];
@@ -161477,6 +162005,9 @@ function buildValueEmitContext(records3, manifest, options = {}) {
     dictionaryKeyOptions: /* @__PURE__ */ new Map(),
     localizedTextIds: /* @__PURE__ */ new Set(),
     constructionReplays: /* @__PURE__ */ new Map(),
+    constructorOwnedArguments: /* @__PURE__ */ new Map(),
+    constructorArgumentGraph: {},
+    constructorRelations: /* @__PURE__ */ new WeakMap(),
     constructorBodySchemaKeys: /* @__PURE__ */ new WeakMap(),
     activeStoredConstructorArguments: /* @__PURE__ */ new Set(),
     materializedConstructors: /* @__PURE__ */ new Map(),
@@ -162154,6 +162685,7 @@ function emitStoredConstructorExpression(context, member, valueId, visited = /*
     context,
     schemaClass2,
     value,
+    resolvedMember,
     className,
     environment,
     visited,
@@ -163347,7 +163879,7 @@ function drainValueReferenceObligationsV4(state, manifest, options) {
       ...composeReferenceSitePosition(move.site, options.sourceTextByUri)
     });
   }
-  for (const obligation of [
+  for (const obligation of options.obligations ?? [
     ...collectionValueObligations(manifest),
     ...options.registry.referenceObligations
   ]) {
@@ -163367,11 +163899,29 @@ function drainValueReferenceObligationsV4(state, manifest, options) {
             targetId = obligation.target.id;
           else if (obligation.target.spelling === "symbol")
             targetId = obligation.target.resolved.id;
+          else if (obligation.target.spelling === "local")
+            targetId = context.localValues.target(obligation.target.name);
           break;
       }
       if (targetId !== void 0 && (options.unavailableValueIds?.has(targetId) === true || options.registry.refusedValueIds.has(targetId)))
         continue;
     }
+    if (options.deferredReferences !== void 0 && obligation.kind === "reference") {
+      const target = obligation.target;
+      if (target.spelling === "local") {
+        const id2 = context.localValues.target(target.name);
+        if (context.pendingValueIdentitySites.get(id2)?.materializedLocation !== void 0) {
+          target.patch.ids[target.patch.index] = id2;
+          options.deferredReferences.push(obligation);
+          continue;
+        }
+      } else if (target.spelling === "id") {
+        if (referenceTargetById(context, target.id, target.typeName) === null) {
+          options.deferredReferences.push(obligation);
+          continue;
+        }
+      }
+    }
     const failure = settleReferenceObligation(
       context,
       obligation,
@@ -166332,10 +166882,24 @@ function lowerAuthoredValueRow(context, member, sourceExpression, expectedValueI
       );
       const checksCanonicalConstruction = requiresCanonicalConstruction && !projectedConstructionEditable;
       if (source.purpose === "stored" && storedConstructorArgs !== null || checksCanonicalConstruction) {
+        const constructionCode = settleInitializerReferenceSpellings(
+          context.localValues.executable(
+            authoredConstruction2,
+            bindingRuntimeIdentifiers(context, source)
+          ).code,
+          (call, site) => settledReferenceTarget(context, call, site, {
+            member: resolvedMember,
+            valueId: expectedValueId,
+            source,
+            expression
+          }),
+          context.syntax
+        ).code;
         const construction = {
           valueId: expectedValueId,
           code: compiledCode,
           construction: authoredConstruction2,
+          constructionCode,
           site: initializerSite
         };
         context.initializerReconciliations.set(
@@ -167221,13 +167785,16 @@ function requiredConstructorProjectionMap(classes, constructors, members2, class
   const required2 = requiredId === void 0 ? void 0 : constructors.get(requiredId);
   if (schemaClass2 === void 0 || required2 === void 0) return /* @__PURE__ */ new Map();
   const result = /* @__PURE__ */ new Map();
+  const parameterNames = new Set(
+    required2.arguments.map((parameter4) => parameter4.name)
+  );
   for (const memberId of Object.values(schemaClass2.schema)) {
     const initializer = members2.get(memberId)?.defaultValue;
     if (initializer === null || initializer === void 0 || !("init" in initializer)) {
       continue;
     }
     const parameterName = initializer.init.code.trim();
-    if (required2.arguments.some((parameter4) => parameter4.name === parameterName)) {
+    if (parameterNames.has(parameterName)) {
       result.set(parameterName, memberId);
     }
   }
@@ -167242,7 +167809,7 @@ function requiredConstructorProjectionMap(classes, constructors, members2, class
   );
   for (const forwarded of required2.baseArguments ?? []) {
     const sourceName = forwarded.code.trim();
-    if (!required2.arguments.some((parameter4) => parameter4.name === sourceName)) {
+    if (!parameterNames.has(sourceName)) {
       continue;
     }
     const memberId = base.get(forwarded.name);
@@ -170052,6 +170619,7 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
       context,
       schemaClass2,
       value,
+      member,
       name,
       environment,
       visited,
@@ -170073,6 +170641,7 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
     context,
     schemaClass2,
     value,
+    member,
     name,
     environment,
     visited,
@@ -170154,7 +170723,7 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
       context,
       childMemberId,
       projection.memberIds
-    )) {
+    ) && context.localValues?.byValueId.has(childId) !== true) {
       continue;
     }
     const childMember = context.members.get(childMemberId);
@@ -170251,7 +170820,20 @@ ${fields.map((field) => indentNeoSource(field, 2)).join(",\n")}
     projection.arguments
   ) : targetTyped ? "new()" : `new ${name}()`;
   if (typeof value.id === "string" && (storedConstruction !== null || projection.arguments.length > 0 || schemaClass2.requiredConstructorId !== void 0)) {
-    context.materializedConstructors.set(value.id, constructor2);
+    const usesLocalArguments = storedArgumentEntries.some(
+      ([, id2]) => context.localValues?.byValueId.has(id2)
+    );
+    const canonical = usesLocalArguments ? storedConstructorCallSource(
+      { ...context, localValues: void 0 },
+      schemaClass2,
+      value,
+      member,
+      name,
+      environment,
+      /* @__PURE__ */ new Set(),
+      targetTyped
+    ) : null;
+    context.materializedConstructors.set(value.id, canonical ?? constructor2);
   }
   if (typeof value.id === "string")
     context.materializedConstructorOverrideKeys.set(value.id, overrideKeys);
@@ -170522,6 +171104,7 @@ function materializedValueSubgraphsEqual(context, currentGraph, replayGraph, cur
   const typeInfo = resolveMemberDeclaredTypeInfo(
     resolvedMember,
     document.members,
+    document.classes,
     null,
     genericEnv
   );
@@ -170587,7 +171170,95 @@ function genericSlotIsRequired(context, member, environment) {
   const binding = bindingId === void 0 ? void 0 : context.members.get(bindingId);
   return binding === void 0 || isRequiredMember(binding);
 }
-function storedConstructorCallSource(context, schemaClass2, value, className, environment, visited, targetTyped, cloneAggregateArguments = false) {
+function constructorArgumentGraph(context) {
+  const cached = context.constructorArgumentGraph.value;
+  if (cached !== void 0) return cached;
+  const parents = /* @__PURE__ */ new Map();
+  const graph = context.readMaterializedGraph();
+  for (const [id2, placement] of context.storedPlacements.placementByChildValueId) {
+    const parent = context.values.get(placement.parentValueId);
+    let segment;
+    if (typeof parent?.classId === "string")
+      segment = `!.${placement.schemaKey}`;
+    else {
+      const owner = graph.ownerForValue(placement.parentValueId);
+      const keyEnumId = owner !== void 0 && isMemberDictionaryBase(owner) ? owner.keyEnumId ?? null : null;
+      segment = `![${emitDictionaryKey(placement.schemaKey, dictionaryOptions2(context, keyEnumId))}]`;
+    }
+    parents.set(id2, { parentId: placement.parentValueId, segment });
+  }
+  for (const [id2, row] of context.values) {
+    const children4 = graph.childrenByContainerId.get(id2);
+    if (!Array.isArray(row.value) && children4 === void 0) continue;
+    if (graph.ownerForValue(id2)?.kind !== 6 /* List */) continue;
+    const ids = Array.isArray(row.value) ? row.value : children4?.map((child2) => child2.id) ?? [];
+    for (const [index, childId] of ids.entries())
+      if (typeof childId === "string")
+        parents.set(childId, { parentId: id2, segment: `![${index}]` });
+  }
+  const children3 = /* @__PURE__ */ new Map();
+  for (const [id2, parent] of parents) {
+    const siblings = children3.get(parent.parentId);
+    if (siblings === void 0) children3.set(parent.parentId, [id2]);
+    else siblings.push(id2);
+  }
+  const intervals = /* @__PURE__ */ new Map();
+  let next = 0;
+  const stack = [];
+  for (const id2 of context.values.keys())
+    if (!parents.has(id2)) stack.push({ id: id2, exit: false });
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (frame.exit) {
+      intervals.get(frame.id).end = next;
+      continue;
+    }
+    if (intervals.has(frame.id))
+      throw new Error(
+        `Constructor argument ownership cycle reaches ${frame.id}.`
+      );
+    intervals.set(frame.id, { start: next++, end: 0 });
+    stack.push({ id: frame.id, exit: true });
+    for (const child2 of children3.get(frame.id) ?? [])
+      stack.push({ id: child2, exit: false });
+  }
+  return context.constructorArgumentGraph.value = { parents, intervals };
+}
+function constructorArgumentRelations(context, value, argumentIds) {
+  const cached = context.constructorRelations.get(value);
+  if (cached !== void 0) return cached;
+  const graph = constructorArgumentGraph(context);
+  const ordered = [...argumentIds].flatMap((id2) => {
+    const interval = graph.intervals.get(id2);
+    return interval === void 0 ? [] : [{ id: id2, ...interval }];
+  }).sort((left, right) => left.start - right.start);
+  const stack = [];
+  const result = /* @__PURE__ */ new Map();
+  for (const current of ordered) {
+    while (stack.length > 0 && stack[stack.length - 1].end <= current.start)
+      stack.pop();
+    const parent = stack[stack.length - 1];
+    if (parent !== void 0) result.set(current.id, { parentId: parent.id });
+    stack.push(current);
+  }
+  context.constructorRelations.set(value, result);
+  return result;
+}
+function concreteArgumentTypeName(context, type2, valueId, environment) {
+  const row = context.values.get(valueId);
+  if (typeof row?.classId !== "string")
+    return storedSchemaTypeName(context, type2, environment, valueId);
+  const settled = type2.kind === "generic" ? storedGenericArgumentType(context, type2, environment) : type2;
+  if (settled.kind === "class" && settled.classId === row.classId)
+    return storedSchemaTypeName(context, settled, environment, valueId);
+  return classValueTypeName(
+    context,
+    row.classId,
+    row,
+    valueGenericEnvironment(row, environment)
+  );
+}
+function storedConstructorCallSource(context, schemaClass2, value, member, className, environment, visited, targetTyped, cloneAggregateArguments = false, ownedArguments) {
   const constructorArgs2 = value.constructorArgs;
   if (!isObjectRecord(constructorArgs2)) return null;
   const manifestClass = context.manifestClasses.get(
@@ -170618,7 +171289,103 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
     manifestClass,
     recordedConstructorId
   );
-  const argumentsValue = constructor2.arguments.flatMap((argument2, index) => {
+  const projectedMembers = requiredConstructorProjectionMap(
+    context.manifestClasses,
+    context.manifestConstructors,
+    context.manifestMembers,
+    stringField2(schemaClass2, "id"),
+    /* @__PURE__ */ new Set()
+  );
+  const aggregateTypes = /* @__PURE__ */ new Map();
+  for (const [index, argument2] of constructor2.arguments.entries()) {
+    const id2 = constructorArgs2[`__arg_${index}__`];
+    const type2 = argument2.type.kind === "generic" ? storedGenericArgumentType(context, argument2.type, environment) : argument2.type;
+    if (typeof id2 === "string" && ["class", "interface", "list", "set", "dictionary"].includes(type2.kind))
+      aggregateTypes.set(id2, type2);
+  }
+  const needsGraphReplay = aggregateTypes.size > 1 && [...aggregateTypes.keys()].some(
+    (id2) => constructorArgumentBodySchemaKey(context, value, id2) !== void 0 || !isSharedConstructorArgument(context, id2, false)
+  );
+  const relations = needsGraphReplay ? constructorArgumentRelations(
+    context,
+    value,
+    new Set(aggregateTypes.keys())
+  ) : /* @__PURE__ */ new Map();
+  const relatedArguments = new Set(relations.keys());
+  for (const relation of relations.values())
+    relatedArguments.add(relation.parentId);
+  const readOwnedArguments = () => {
+    const valueId = stringField2(value, "id");
+    const cached = context.constructorOwnedArguments.get(valueId);
+    if (cached !== void 0) return cached;
+    const code = storedConstructorCallSource(
+      context,
+      schemaClass2,
+      value,
+      member,
+      className,
+      environment,
+      /* @__PURE__ */ new Set(),
+      targetTyped,
+      true,
+      new Set(
+        Object.values(constructorArgs2).filter(
+          (argument2) => typeof argument2 === "string"
+        )
+      )
+    );
+    if (code === null)
+      throw new Error(`Stored construction ${valueId} has no replay call.`);
+    if (context.storedValueBase === void 0)
+      context.constructorOwnershipReplayContext ??= context.readReplayContext();
+    if (context.constructorOwnershipReplayContext === void 0) {
+      const document = context.readDocument();
+      let changed = false;
+      const values = document.values.map((row) => {
+        if (!isInitValueContent(row)) return row;
+        const stored = context.storedValueBase?.get(row.id);
+        if (!isMemberValue(stored) || !isLiteralValueContent(stored))
+          return row;
+        changed = true;
+        return stored;
+      });
+      context.constructorOwnershipReplayContext = changed ? createPulledConstructionReplayContext({
+        document: { ...document, values }
+      }) : context.readReplayContext();
+    }
+    const replayContext = context.constructorOwnershipReplayContext;
+    const rows = replayStoredConstructionV4({
+      records: context.records,
+      document: replayContext.document,
+      valueId,
+      code,
+      member: concreteClassMemberForReplay(context, member, environment),
+      compilationProject: context.readCompilationProject(),
+      replayContext
+    });
+    const root = rows.get(valueId);
+    const bodyIds = new Set(
+      isObjectRecord(root?.value) ? Object.values(root.value) : []
+    );
+    const replayArguments2 = isObjectRecord(root?.constructorArgs) ? root.constructorArgs : {};
+    const owned = /* @__PURE__ */ new Set();
+    for (const [key, argument2] of Object.entries(constructorArgs2)) {
+      if (typeof argument2 === "string" && bodyIds.has(replayArguments2[key]))
+        owned.add(argument2);
+    }
+    context.constructorOwnedArguments.set(valueId, owned);
+    const allBodyArgumentsOwned = Object.values(constructorArgs2).every(
+      (argument2) => constructorArgumentBodySchemaKey(context, value, argument2) === void 0 || typeof argument2 === "string" && owned.has(argument2)
+    );
+    if (allBodyArgumentsOwned && replayContext.document === context.readDocument())
+      context.constructionReplays.set(valueId, rows);
+    return owned;
+  };
+  const argumentUses = /* @__PURE__ */ new Map();
+  for (const argument2 of Object.values(constructorArgs2))
+    if (typeof argument2 === "string")
+      argumentUses.set(argument2, (argumentUses.get(argument2) ?? 0) + 1);
+  const preparedArguments = constructor2.arguments.flatMap((argument2, index) => {
     const key = `__arg_${index}__`;
     if (!(key in constructorArgs2)) {
       if (argument2.default !== null || argument2.type.nullable) return [];
@@ -170631,42 +171398,132 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
       schemaClass2,
       value,
       constructorArgs2[key],
-      argument2.name
+      argument2.name,
+      projectedMembers
     );
-    return [
-      `${argument2.name}: ${storedConstructorArgumentSource(
+    const bodySchemaKey = constructorArgumentBodySchemaKey(
+      context,
+      value,
+      constructorArgs2[key]
+    );
+    let constructorOwnsGraph = bodySchemaKey !== void 0;
+    const argumentValue = constructorArgs2[key];
+    if (constructorOwnsGraph && typeof argumentValue === "string") {
+      if (ownedArguments !== void 0)
+        constructorOwnsGraph = ownedArguments.has(argumentValue);
+      else if (projectedMembers.has(argument2.name) && argumentUses.get(argumentValue) === 1 && !relatedArguments.has(argumentValue))
+        constructorOwnsGraph = settledMember?.kind !== 9 /* Lookup */;
+      else constructorOwnsGraph = readOwnedArguments().has(argumentValue);
+    }
+    return [{ argument: argument2, argumentValue, settledMember, constructorOwnsGraph }];
+  });
+  const replayArguments = new Map(
+    preparedArguments.flatMap(
+      (entry) => typeof entry.argumentValue === "string" && aggregateTypes.has(entry.argumentValue) ? [[entry.argumentValue, entry]] : []
+    )
+  );
+  const ownedReplayArguments = new Set(
+    preparedArguments.flatMap(
+      (entry) => entry.constructorOwnsGraph && typeof entry.argumentValue === "string" ? [entry.argumentValue] : []
+    )
+  );
+  const bindings = /* @__PURE__ */ new Map();
+  const declarations = [];
+  const bindArgument = (id2) => {
+    const bound = bindings.get(id2);
+    if (bound !== void 0) return bound;
+    const entry = replayArguments.get(id2);
+    if (entry === void 0)
+      throw new Error(
+        `Constructor replay argument ${id2} has no typed parameter.`
+      );
+    const relation = relations.get(id2);
+    const parent = relation === void 0 ? void 0 : bindArgument(relation.parentId);
+    const name = `__neo_argument_${bindings.size}`;
+    const typeName = concreteArgumentTypeName(
+      context,
+      entry.argument.type,
+      id2,
+      environment
+    );
+    if (relation !== void 0 && parent !== void 0) {
+      const graph = constructorArgumentGraph(context);
+      const path = [];
+      let cursor = id2;
+      while (!bindings.has(cursor)) {
+        const edge = graph.parents.get(cursor);
+        if (edge === void 0)
+          throw new Error(
+            `Constructor argument ${cursor} has no owning path to ${relation.parentId}.`
+          );
+        path.push({ id: cursor, segment: edge.segment });
+        cursor = edge.parentId;
+      }
+      let receiver = bindings.get(cursor);
+      for (const step of path.reverse()) {
+        const stepName = `__neo_argument_${bindings.size}`;
+        const source = `${receiver}${step.segment}`;
+        const row = context.values.get(step.id);
+        if (typeof row?.classId === "string") {
+          const concreteType = step.id === id2 ? typeName : classValueTypeName(
+            context,
+            row.classId,
+            row,
+            valueGenericEnvironment(row, environment)
+          );
+          declarations.push(
+            `if (${source} is not ${concreteType} ${stepName}) throw ${quote3(`Constructor argument path ${step.id} no longer has type ${concreteType}.`)};`
+          );
+        } else declarations.push(`var ${stepName} = ${source}!;`);
+        bindings.set(step.id, stepName);
+        receiver = stepName;
+      }
+      return receiver;
+    } else {
+      const owns = ownedArguments?.has(id2) ?? ownedReplayArguments.has(id2);
+      const source = storedConstructorArgumentSource(
         context,
-        argument2.type,
-        constructorArgs2[key],
+        entry.argument.type,
+        id2,
         environment,
         visited,
-        cloneAggregateArguments,
-        settledMember?.payload === 1 /* Partial */,
-        // Emit the argument's graph INLINE only when this row's own body names
-        // it. A P75-sparse root settles a member through the declared
-        // projection instead (see `settledMemberForConstructorArgument`), and
-        // that answer is a spelling fact, not an ownership fact: a shared
-        // collection row passed as `new Placed(item)` settles `Item` while
-        // staying owned by `root.Assets.Items`. Reading it as ownership
-        // re-declared that external graph under the construction, and the
-        // emitter then refused the whole pull with a containment cycle on the
-        // re-declared row's own children.
-        constructorArgumentBodySchemaKey(
-          context,
-          value,
-          constructorArgs2[key]
-        ) !== void 0
-      )}`
-    ];
+        true,
+        entry.settledMember?.payload === 1 /* Partial */,
+        owns
+      );
+      declarations.push(`${typeName} ${name} = ${source};`);
+    }
+    bindings.set(id2, name);
+    return name;
+  };
+  const argumentsValue = preparedArguments.map((entry) => {
+    const { argument: argument2, argumentValue, settledMember, constructorOwnsGraph } = entry;
+    if (cloneAggregateArguments && typeof argumentValue === "string" && aggregateTypes.has(argumentValue) && ((argumentUses.get(argumentValue) ?? 0) > 1 || relatedArguments.has(argumentValue)))
+      return `${argument2.name}: ${bindArgument(argumentValue)}`;
+    return `${argument2.name}: ${storedConstructorArgumentSource(
+      context,
+      argument2.type,
+      argumentValue,
+      environment,
+      visited,
+      cloneAggregateArguments,
+      settledMember?.payload === 1 /* Partial */,
+      constructorOwnsGraph
+    )}`;
   });
-  return constructorCallSource(
+  const call = constructorCallSource(
     targetTyped ? "new" : `new ${className}`,
     argumentsValue
   );
+  return declarations.length === 0 ? call : `(() => { ${declarations.join(" ")} return ${call}; })()`;
 }
-function settledMemberForConstructorArgument(context, schemaClass2, value, argument2, argumentName) {
+function settledMemberForConstructorArgument(context, schemaClass2, value, argument2, argumentName, projectedMembers) {
   if (typeof argument2 !== "string") return void 0;
   const schema = isObjectRecord(schemaClass2.schema) ? schemaClass2.schema : {};
+  const projectedMemberId = projectedMembers.get(argumentName);
+  if (projectedMemberId !== void 0) {
+    return context.members.get(projectedMemberId);
+  }
   const bodySchemaKey = constructorArgumentBodySchemaKey(
     context,
     value,
@@ -170675,16 +171532,6 @@ function settledMemberForConstructorArgument(context, schemaClass2, value, argum
   if (bodySchemaKey !== void 0) {
     return memberForSchemaKey(context, schema, bodySchemaKey);
   }
-  const projectedMemberId = requiredConstructorProjectionMap(
-    context.manifestClasses,
-    context.manifestConstructors,
-    context.manifestMembers,
-    stringField2(schemaClass2, "id"),
-    /* @__PURE__ */ new Set()
-  ).get(argumentName);
-  if (projectedMemberId !== void 0) {
-    return context.members.get(projectedMemberId);
-  }
   const namedSchemaKey = schemaKeyForParameterName(schema, argumentName);
   return namedSchemaKey === void 0 ? void 0 : memberForSchemaKey(context, schema, namedSchemaKey);
 }
@@ -171187,7 +172034,12 @@ function storedAggregateReplaySource(context, type2, valueId, environment, const
       `Stored ${type2.kind} constructor argument references missing value row ${valueId}.`
     );
   }
-  const typeName = storedSchemaTypeName(context, type2, environment, valueId);
+  const typeName = concreteArgumentTypeName(
+    context,
+    type2,
+    valueId,
+    environment
+  );
   const reference2 = `Reference<${typeName}>(id: ${quote3(valueId)})`;
   return isSharedConstructorArgument(context, valueId, constructorOwnsGraph) ? reference2 : `${reference2}.Clone()`;
 }
@@ -171358,8 +172210,10 @@ function storedTypedRowSource(context, type2, valueId, environment, visited, wri
       );
     }
   }
-  if (isSharedConstructorArgument(context, valueId, constructorOwnsGraph)) {
-    return `Reference<${storedSchemaTypeName(context, type2, environment, valueId)}>(id: ${quote3(valueId)})`;
+  if (context.localValues?.byValueId.has(valueId) || isSharedConstructorArgument(context, valueId, constructorOwnsGraph)) {
+    const local = context.localValues?.byValueId.get(valueId);
+    const target = local === void 0 ? `id: ${quote3(valueId)}` : local.name;
+    return `Reference<${storedSchemaTypeName(context, type2, environment, valueId)}>(${target})`;
   }
   if (context.activeStoredConstructorArguments.has(valueId)) {
     throw new Error(
@@ -171923,7 +172777,7 @@ function referenceValue(context, member, body, dialogue, slotTypeName = null) {
         return `Reference<${dialogueSymbol}>(${dialogueSymbol})`;
       }
     }
-    const symbol = context.localValues?.byValueId.get(id2)?.name ?? context.symbolsByValueId.get(id2);
+    const symbol = (context.values.has(id2) ? context.localValues?.byValueId.get(id2)?.name : void 0) ?? context.symbolsByValueId.get(id2);
     if (symbol !== void 0) return `Reference(${symbol})`;
     if (slotTypeName !== null) {
       const path = slotRootPath(context, id2);
@@ -173197,7 +174051,9 @@ function buildNeoScriptProject(document) {
     classes: document.classes,
     enums: document.enums,
     interfaces: document.interfaces,
-    constructors: document.constructors ?? []
+    constructors: document.constructors ?? [],
+    variants: document.variants,
+    variantFolders: document.variantFolders
   });
 }
 function neoScriptProjectFingerprint(document) {
@@ -173413,9 +174269,7 @@ function reconcileMaterializedInitializersV4(args) {
         member: owner,
         compilationProject: project
       });
-      const authored = compiled(
-        constructorExpressionSlice(reconciliation.code)
-      );
+      const authored = compiled(reconciliation.constructionCode);
       if (authored === null || !sameCompiledProgram(authored, compiled(canonicalExpression))) {
         replayableValueIds.add(valueId);
       }
@@ -173847,6 +174701,13 @@ function materializeInitializersLocallyV4(args) {
     },
     valueIds: compiledBodyIds
   });
+  const failures = [];
+  const unavailableRootIds = /* @__PURE__ */ new Set();
+  const onFailure = args.collectErrors === true ? (ids, error) => {
+    const dependent = error instanceof PendingInitializerDependency && unavailableRootIds.has(error.valueId);
+    for (const id2 of ids) unavailableRootIds.add(id2);
+    if (!dependent) failures.push(error);
+  } : void 0;
   const compiledInitializers = /* @__PURE__ */ new Map();
   const templateContext = createPulledConstructionReplayContext({
     document: authoredDocument,
@@ -173859,19 +174720,25 @@ function materializeInitializersLocallyV4(args) {
       walkedRootOwners,
       batch.valuesById
     );
-    replayStoredConstructionV4({
-      records: records3,
-      document: authoredDocument,
-      valueId: id2,
-      code: initializerCode(records3, id2),
-      compilationProject,
-      replayContext: templateContext,
-      member: rootOwners.get(id2),
-      initializerOwnerClass: ownerContext.declaringClass,
-      lexicalThisClass: ownerContext.lexicalThisClass,
-      evaluate: false,
-      onCompiledInitializer: (init) => compiledInitializers.set(id2, init)
-    });
+    try {
+      replayStoredConstructionV4({
+        records: records3,
+        document: authoredDocument,
+        valueId: id2,
+        code: initializerCode(records3, id2),
+        compilationProject,
+        replayContext: templateContext,
+        member: rootOwners.get(id2),
+        initializerOwnerClass: ownerContext.declaringClass,
+        lexicalThisClass: ownerContext.lexicalThisClass,
+        evaluate: false,
+        onCompiledInitializer: (init) => compiledInitializers.set(id2, init)
+      });
+    } catch (error) {
+      if (onFailure === void 0) throw error;
+      onFailure([id2], error);
+      pendingRoots.delete(id2);
+    }
   }
   const typeMembers = compiledConstructionTypeMembers(
     authoredDocument.members,
@@ -173886,135 +174753,169 @@ function materializeInitializersLocallyV4(args) {
     batch = createInitializerMaterializationBatch(replayDocument, pendingRoots);
   }
   batch.upsert(compiledClosures);
-  materializeInitializerDependencies(pendingRoots, (sourceValueId) => {
-    const batchDocument = batch.document();
-    const document = {
-      ...replayDocument,
-      values: batchDocument.values,
-      databaseVM: batchDocument.databaseVM
-    };
-    const rootOwner = rootOwners.get(sourceValueId);
-    if (rootOwner === void 0) {
-      throw new Error(
-        `CLI initializer materialization cannot resolve the owning member for root "${sourceValueId}".`
-      );
-    }
-    const replayContext = createPulledConstructionReplayContext({
-      document,
-      valuesById: batch.valuesById
-    });
-    const code = initializerCode(records3, sourceValueId);
-    let compiledInitializer;
-    let pinned = {
-      pinnedRootSchemaKeys: /* @__PURE__ */ new Set(),
-      pinnedSchemaKeysByValueId: /* @__PURE__ */ new Map()
-    };
-    const evaluated = replayStoredConstructionV4({
-      records: records3,
-      document,
-      valueId: sourceValueId,
-      code,
-      compilationProject,
-      replayContext,
-      member: rootOwner,
-      compiledInitializer: compiledInitializers.get(sourceValueId),
-      onCompiledInitializer: (init) => {
-        compiledInitializer = init;
-        compiledInitializers.set(sourceValueId, init);
-      },
-      onConstructionPreservation: (keys) => {
-        pinned = keys;
+  const resolvedLocalIds = /* @__PURE__ */ new Map();
+  materializeInitializerDependencies(
+    pendingRoots,
+    (sourceValueId) => {
+      const batchDocument = batch.document();
+      const database = batchDocument.databaseVM;
+      if (database !== void 0) {
+        batchDocument.databaseVM = {
+          ...database,
+          valueById: (id2) => {
+            if (unavailableRootIds.has(id2))
+              throw new PendingInitializerDependency(id2);
+            const location3 = args.localReferenceLocations?.get(id2);
+            if (location3 === void 0) return database.valueById(id2);
+            if (unavailableRootIds.has(location3.rootId))
+              throw new PendingInitializerDependency(location3.rootId);
+            if (pendingRoots.has(location3.rootId))
+              throw new PendingInitializerDependency(location3.rootId);
+            const target = resolvedLocalIds.get(id2) ?? storedValueAtPathV4(
+              batch.valuesById,
+              location3.rootId,
+              location3.path
+            );
+            if (target === null)
+              throw new Error(
+                `Local value ${id2} has no row at its owning path.`
+              );
+            resolvedLocalIds.set(id2, target);
+            return database.valueById(target);
+          }
+        };
       }
-    });
-    const evaluatedRoot = evaluated.get(sourceValueId);
-    if (evaluatedRoot === void 0 || !isMemberValue(evaluatedRoot)) {
-      throw new Error(
-        `CLI initializer materialization produced no root row for value "${sourceValueId}".`
-      );
-    }
-    if (compiledInitializer === void 0) {
-      throw new Error(
-        `CLI initializer materialization did not compile root "${sourceValueId}".`
-      );
-    }
-    const evaluatedChildren = [...evaluated.entries()].flatMap(([id2, row]) => {
-      if (id2 === sourceValueId) return [];
-      if (!isMemberValue(row)) {
+      const document = {
+        ...replayDocument,
+        values: batchDocument.values,
+        databaseVM: batchDocument.databaseVM
+      };
+      const rootOwner = rootOwners.get(sourceValueId);
+      if (rootOwner === void 0) {
         throw new Error(
-          `CLI initializer materialization for "${sourceValueId}" produced an invalid value row.`
+          `CLI initializer materialization cannot resolve the owning member for root "${sourceValueId}".`
         );
       }
-      return [row];
-    });
-    const baseline = replayStoredConstructionV4({
-      records: records3,
-      document,
-      valueId: sourceValueId,
-      code,
-      compilationProject,
-      replayContext,
-      member: rootOwner,
-      compiledInitializer,
-      omitConstructionFields: true
-    });
-    const baselineRoot = baseline.get(sourceValueId);
-    if (baselineRoot === void 0 || !isMemberValue(baselineRoot)) {
-      throw new Error(
-        `CLI initializer baseline produced no root row for value "${sourceValueId}".`
+      const replayContext = createPulledConstructionReplayContext({
+        document,
+        valuesById: batch.valuesById
+      });
+      const code = initializerCode(records3, sourceValueId);
+      let compiledInitializer;
+      let pinned = {
+        pinnedRootSchemaKeys: /* @__PURE__ */ new Set(),
+        pinnedSchemaKeysByValueId: /* @__PURE__ */ new Map()
+      };
+      const evaluated = replayStoredConstructionV4({
+        records: records3,
+        document,
+        valueId: sourceValueId,
+        code,
+        compilationProject,
+        replayContext,
+        member: rootOwner,
+        compiledInitializer: compiledInitializers.get(sourceValueId),
+        onCompiledInitializer: (init) => {
+          compiledInitializer = init;
+          compiledInitializers.set(sourceValueId, init);
+        },
+        onConstructionPreservation: (keys) => {
+          pinned = keys;
+        }
+      });
+      const evaluatedRoot = evaluated.get(sourceValueId);
+      if (evaluatedRoot === void 0 || !isMemberValue(evaluatedRoot)) {
+        throw new Error(
+          `CLI initializer materialization produced no root row for value "${sourceValueId}".`
+        );
+      }
+      if (compiledInitializer === void 0) {
+        throw new Error(
+          `CLI initializer materialization did not compile root "${sourceValueId}".`
+        );
+      }
+      const evaluatedChildren = [...evaluated.entries()].flatMap(
+        ([id2, row]) => {
+          if (id2 === sourceValueId) return [];
+          if (!isMemberValue(row)) {
+            throw new Error(
+              `CLI initializer materialization for "${sourceValueId}" produced an invalid value row.`
+            );
+          }
+          return [row];
+        }
       );
-    }
-    const baselineChildren = [...baseline.entries()].flatMap(([id2, row]) => {
-      if (id2 === sourceValueId) return [];
-      if (!isMemberValue(row)) {
+      const baseline = replayStoredConstructionV4({
+        records: records3,
+        document,
+        valueId: sourceValueId,
+        code,
+        compilationProject,
+        replayContext,
+        member: rootOwner,
+        compiledInitializer,
+        omitConstructionFields: true
+      });
+      const baselineRoot = baseline.get(sourceValueId);
+      if (baselineRoot === void 0 || !isMemberValue(baselineRoot)) {
         throw new Error(
-          `CLI initializer baseline for "${sourceValueId}" produced an invalid value row.`
+          `CLI initializer baseline produced no root row for value "${sourceValueId}".`
         );
       }
-      return [row];
-    });
-    const sparse2 = sparsifyConstructedInstance({
-      localizedTextIds,
-      document,
-      rootMember: rootOwner,
-      constructed: {
-        root: evaluatedRoot,
-        createdChildren: evaluatedChildren
-      },
-      baseline: {
-        root: baselineRoot,
-        createdChildren: baselineChildren
-      },
-      // §4: a call-site field is an explicit override even when it equals the
-      // class default, so the evaluated construction's own field list is what
-      // pins rows against collapse. Push preparation pins the same set.
-      snapshot: pinned.snapshot,
-      pinnedRootSchemaKeys: pinned.pinnedRootSchemaKeys,
-      pinnedSchemaKeysByValueId: pinned.pinnedSchemaKeysByValueId,
-      bindingTargets,
-      virtualValueIdForSource: (instanceRootId, sourceIdentity3) => isPendingId(instanceRootId) || hasPendingVirtualSourceIdentity(sourceIdentity3) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3)
-    });
-    const evaluatedRows = [sparse2.root, ...sparse2.createdChildren];
-    assertStoredClosuresKeepNoCaptures({
-      sourceValueId,
-      rows: evaluatedRows,
-      constructors: document.constructors ?? []
-    });
-    roots.push({
-      sourceValueId,
-      rows: evaluatedRows.map((row) => ({ ...row }))
-    });
-    for (const row of evaluatedRows) {
-      records3.set(`value:${row.id}`, {
-        recordKind: "value",
-        recordId: row.id,
-        contentHash: "local-materialization",
-        deleted: false,
-        data: row
+      const baselineChildren = [...baseline.entries()].flatMap(([id2, row]) => {
+        if (id2 === sourceValueId) return [];
+        if (!isMemberValue(row)) {
+          throw new Error(
+            `CLI initializer baseline for "${sourceValueId}" produced an invalid value row.`
+          );
+        }
+        return [row];
       });
-    }
-    batch.upsert(evaluatedRows);
-  });
-  if (validatesTouched) {
+      const sparse2 = sparsifyConstructedInstance({
+        localizedTextIds,
+        document,
+        rootMember: rootOwner,
+        constructed: {
+          root: evaluatedRoot,
+          createdChildren: evaluatedChildren
+        },
+        baseline: {
+          root: baselineRoot,
+          createdChildren: baselineChildren
+        },
+        // §4: a call-site field is an explicit override even when it equals the
+        // class default, so the evaluated construction's own field list is what
+        // pins rows against collapse. Push preparation pins the same set.
+        snapshot: pinned.snapshot,
+        pinnedRootSchemaKeys: pinned.pinnedRootSchemaKeys,
+        pinnedSchemaKeysByValueId: pinned.pinnedSchemaKeysByValueId,
+        bindingTargets,
+        virtualValueIdForSource: (instanceRootId, sourceIdentity3) => isPendingId(instanceRootId) || hasPendingVirtualSourceIdentity(sourceIdentity3) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3)
+      });
+      const evaluatedRows = [sparse2.root, ...sparse2.createdChildren];
+      assertStoredClosuresKeepNoCaptures({
+        sourceValueId,
+        rows: evaluatedRows,
+        constructors: document.constructors ?? []
+      });
+      roots.push({
+        sourceValueId,
+        rows: evaluatedRows.map((row) => ({ ...row }))
+      });
+      for (const row of evaluatedRows) {
+        records3.set(`value:${row.id}`, {
+          recordKind: "value",
+          recordId: row.id,
+          contentHash: "local-materialization",
+          deleted: false,
+          data: row
+        });
+      }
+      batch.upsert(evaluatedRows);
+    },
+    onFailure
+  );
+  if (validatesTouched && failures.length === 0) {
     assertPulledConstructorsCompiled(pulledDocument);
     const batchDocument = batch.document();
     const document = {
@@ -174023,19 +174924,34 @@ function materializeInitializersLocallyV4(args) {
       values: batchDocument.values,
       databaseVM: batchDocument.databaseVM
     };
-    assertTouchedInitializersConstruct({
-      document: {
-        ...document,
-        initializerCompiler: documentInitializerCompiler(
-          document,
-          compilationProject
-        )
-      },
-      prepared: written,
-      replayedValueIds: replayedRoots
-    });
+    try {
+      assertTouchedInitializersConstruct({
+        document: {
+          ...document,
+          initializerCompiler: documentInitializerCompiler(
+            document,
+            compilationProject
+          )
+        },
+        prepared: written,
+        replayedValueIds: replayedRoots
+      });
+    } catch (error) {
+      if (onFailure === void 0) throw error;
+      onFailure([], error);
+    }
   }
-  return { roots };
+  for (const [id2, location3] of args.localReferenceLocations ?? []) {
+    if (resolvedLocalIds.has(id2)) continue;
+    if (unavailableRootIds.has(location3.rootId)) continue;
+    const target = storedValueAtPathV4(
+      batch.valuesById,
+      location3.rootId,
+      location3.path
+    );
+    if (target !== null) resolvedLocalIds.set(id2, target);
+  }
+  return { roots, resolvedLocalIds, failures, unavailableRootIds };
 }
 function prospectiveInitializerRecordsV4(args) {
   const records3 = /* @__PURE__ */ new Map();
@@ -174165,10 +175081,10 @@ var cleanRetainedCode, pulledStateDocuments;
 var init_local_initializer_materialization = __esm({
   "src/project-source/local-initializer-materialization.ts"() {
     "use strict";
+    init_stored_value_placements();
     init_local_project_file_storage();
     init_immutable_json3();
     init_lexer();
-    init_init_source();
     init_NSGetterRuntimeError();
     init_runtime_diagnostic();
     init_evaluateInitializer();
@@ -176862,6 +177778,7 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
   );
   for (const extension of analysis.schema.extensions ?? [])
     lowerExtension(context, extension);
+  retainStoredMemberDependencies(context);
   normalizeLookupDeclaredTypes(context);
   for (const [memberId, placements] of context.placements) {
     const member = context.loweredMembers.get(memberId);
@@ -176870,9 +177787,6 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
     context.loweredMembers.set(memberId, { ...member, owner });
   }
   const protectedRootMembers = lowerProtectedRootMembers(base, analysis);
-  const structuralMembers = base.members.filter(
-    (member) => (member.owner.kind === "genericArgument" || member.owner.kind === "sharedGenericArgument") && !context.loweredMembers.has(member.id)
-  );
   return {
     ...base,
     classes,
@@ -176881,8 +177795,7 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
       ...context.loweredMembers.values(),
       ...protectedRootMembers.filter(
         (member) => !context.loweredMembers.has(member.id)
-      ),
-      ...structuralMembers
+      )
     ],
     interfaces,
     enums: analysis.schema.enums.map(
@@ -176893,6 +177806,43 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
     internalRecordRelations: lowerRelations(context, analysis)
   };
 }
+function retainStoredMemberDependencies(context) {
+  const retain = (memberId) => {
+    if (context.loweredMembers.has(memberId)) return;
+    const member = context.baseMembers.get(memberId);
+    if (member === void 0)
+      throw new Error(
+        `Stored generic or collection descriptor ${memberId} is missing.`
+      );
+    context.loweredMembers.set(memberId, member);
+  };
+  const retainDependencies = (member) => {
+    switch (member.kind) {
+      case "class":
+        for (const binding of Object.values(member.classArguments))
+          if (binding.kind === "member") retain(binding.memberId);
+        break;
+      case "interface":
+        for (const binding of Object.values(member.interfaceArguments))
+          if (binding.kind === "member") retain(binding.memberId);
+        break;
+      case "list":
+      case "set":
+      case "dictionary":
+        retain(member.entryMemberId);
+        break;
+      case "tuple":
+        for (const element of member.elementMemberIds) retain(element);
+        break;
+    }
+  };
+  for (const member of context.baseMembers.values()) {
+    if (member.owner.kind === "loose" && !context.loweredMembers.has(member.id))
+      retainDependencies(member);
+  }
+  for (const member of context.loweredMembers.values())
+    retainDependencies(member);
+}
 function lowerProtectedRootMembers(base, analysis) {
   const candidates = PROJECT_ROOT_SOURCE_SLOTS.map(
     (slot) => base.members.filter(
@@ -180397,48 +181347,60 @@ function recordDeleteChange(base, file) {
     casBaseHash: base.conflictServerHash ?? base.contentHash
   };
 }
-function appendCollectionEntryDeletes(workspace, reconstructed3, changes) {
-  const releasedOwnerIds = /* @__PURE__ */ new Set();
+function appendOwnedSchemaMemberDeletes(workspace, reconstructed3, changes, baseManifest) {
+  const owners = /* @__PURE__ */ new Set();
+  const deleted = /* @__PURE__ */ new Set();
   for (const change of changes) {
-    if (change.recordKind !== "member") continue;
-    if (change.kind === "delete") {
-      releasedOwnerIds.add(change.recordId);
-      continue;
+    if (change.kind === "create") continue;
+    if (!["class", "interface", "member"].includes(change.recordKind)) continue;
+    owners.add(change.recordId);
+    if (change.kind === "delete") deleted.add(change.recordId);
+    const record7 = workspace.state.records[recordStateKey(change.recordKind, change.recordId)];
+    const data = record7 === void 0 ? void 0 : effectiveRecordData(record7);
+    const parameters = isObjectRecord(data) ? data.genericParams : void 0;
+    if (Array.isArray(parameters)) {
+      for (const parameter4 of parameters) {
+        if (isObjectRecord(parameter4) && typeof parameter4.id === "string")
+          owners.add(parameter4.id);
+      }
     }
-    const base = workspace.state.records[recordStateKey("member", change.recordId)];
-    if (base === void 0) continue;
-    const data = effectiveRecordData(base);
-    if (isObjectRecord(data) && typeof data.entryMemberId === "string" && data.entryMemberId !== change.nextData?.entryMemberId)
-      releasedOwnerIds.add(change.recordId);
   }
-  if (releasedOwnerIds.size === 0) return;
-  const members2 = /* @__PURE__ */ new Map();
-  function setOwnership(id2, data) {
-    if (!isObjectRecord(data)) return;
-    const entryMemberId = data.entryMemberId;
-    members2.set(id2, {
-      id: id2,
-      // Reconstructed entries survive, including entries moved to a new owner.
-      ...typeof entryMemberId === "string" && !reconstructed3.has(recordStateKey("member", entryMemberId)) ? { entryMemberId } : {}
-    });
+  if (owners.size === 0) return;
+  const children3 = /* @__PURE__ */ new Map();
+  const add = (parent, child2) => {
+    const entries = children3.get(parent) ?? [];
+    entries.push(child2);
+    children3.set(parent, entries);
+  };
+  for (const member of baseManifest?.members ?? []) {
+    switch (member.owner.kind) {
+      case "genericArgument":
+        add(member.owner.parentRecordId, member.id);
+        break;
+      case "sharedGenericArgument":
+        for (const binding of member.owner.bindings)
+          add(binding.parentRecordId, member.id);
+        break;
+      case "collectionEntry":
+        add(member.owner.parentMemberId, member.id);
+        break;
+      case "sharedCollectionEntry":
+        for (const parent of member.owner.parentMemberIds)
+          add(parent, member.id);
+        break;
+    }
   }
-  for (const record7 of Object.values(workspace.state.records)) {
-    if (record7.recordKind === "member" && record7.conflictServerHash !== null)
-      setOwnership(record7.recordId, effectiveRecordData(record7));
-  }
-  for (const record7 of reconstructed3.values()) {
-    if (record7.recordKind === "member" && !releasedOwnerIds.has(record7.recordId))
-      setOwnership(record7.recordId, record7.fullData);
-  }
-  const dependentIds = new Set(releasedOwnerIds);
-  addDependentMemberIds(dependentIds, members2.values());
-  for (const id2 of dependentIds) {
-    if (releasedOwnerIds.has(id2)) continue;
-    const key = recordStateKey("member", id2);
-    if (reconstructed3.has(key)) continue;
-    const base = workspace.state.records[key];
-    if (base === void 0 || base.conflictServerHash === null) continue;
-    changes.push(recordDeleteChange(base, base.file ?? null));
+  for (const ownerId of owners) {
+    for (const memberId of children3.get(ownerId) ?? []) {
+      const key = recordStateKey("member", memberId);
+      if (reconstructed3.has(key)) continue;
+      owners.add(memberId);
+      if (deleted.has(memberId)) continue;
+      const base = workspace.state.records[key];
+      if (base === void 0 || base.conflictServerHash === null) continue;
+      deleted.add(memberId);
+      changes.push(recordDeleteChange(base, base.file ?? null));
+    }
   }
 }
 function listVirtualProjectSourceFilesV4(files) {
@@ -180463,10 +181425,16 @@ function compareWorkspacePaths(left, right) {
   if (left > right) return 1;
   return 0;
 }
-function materializeWorkspaceStatusInitializers(workspace, status, forceRecompile) {
+function materializeWorkspaceStatusInitializers(workspace, status, forceRecompile, collectErrors = false) {
   return materializeInitializersLocallyV4({
     workspace,
     forceRecompile,
+    collectErrors,
+    localReferenceLocations: new Map(
+      [...status.pendingValueIdentitySites ?? []].flatMap(
+        ([id2, site]) => site.materializedLocation === void 0 ? [] : [[id2, site.materializedLocation]]
+      )
+    ),
     changes: status.changes.map((change) => ({
       recordKind: change.recordKind,
       recordId: change.recordId,
@@ -181472,12 +182440,19 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     }
     changes.push(recordDeleteChange(recordState, recordFile));
   }
-  appendCollectionEntryDeletes(workspace, reconstructed3, changes);
+  appendOwnedSchemaMemberDeletes(
+    workspace,
+    reconstructed3,
+    changes,
+    baseManifest
+  );
+  const deferredReferences = [];
   const referenceFailures = drainValueReferenceObligationsV4(
     prospectiveState,
     manifest,
     {
       registry: valueLowerRegistry,
+      deferredReferences,
       analysis: projectAnalysisV4,
       deletedValueIds,
       unavailableReferenceMemberIds,
@@ -181528,6 +182503,17 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
       reconciliations: valueLowerRegistry.initializerReconciliations
     });
   }
+  const localReferenceTargets = valueLowerRegistry.localValues?.referenceTargets();
+  if (localReferenceTargets !== void 0 && localReferenceTargets.size > 0) {
+    const rewrite = createIdentityRewriter(localReferenceTargets);
+    authoredValueSeeds = settleInitializerKeyCode({
+      settle: rewrite,
+      seeds: authoredValueSeeds,
+      reconstructed: reconstructed3,
+      changes,
+      reconciliations: valueLowerRegistry.initializerReconciliations
+    });
+  }
   try {
     const listeners = lowerListenerBindings({
       statements: projectAnalysisV4?.listenerStatements,
@@ -181891,16 +182877,143 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
       )
     );
   }
-  if (options.skipInitializerMaterialization !== true && !parseErrors.some(isBlockingSchemaSourceError)) {
-    const diagnostic = workspaceStatusInitializerDiagnostic(
-      workspace,
-      { changes, authoredValueSeeds },
-      valueLowerRegistry.initializerSites,
-      sourceTextByUri,
-      projectAnalysisV4,
-      options.forceRecompile
-    );
-    if (diagnostic !== null) parseErrors.push(diagnostic);
+  const hasUnresolvedLocalReferences = deferredReferences.length > 0 || [...localReferenceTargets?.values() ?? []].some(
+    (id2) => valueLowerRegistry.pendingValueIdentitySites.get(id2)?.materializedLocation !== void 0
+  );
+  if (hasUnresolvedLocalReferences || options.skipInitializerMaterialization !== true && !parseErrors.some(isBlockingSchemaSourceError)) {
+    if (hasUnresolvedLocalReferences) {
+      try {
+        const materialized = materializeWorkspaceStatusInitializers(
+          workspace,
+          {
+            changes,
+            authoredValueSeeds,
+            pendingValueIdentitySites: valueLowerRegistry.pendingValueIdentitySites
+          },
+          options.forceRecompile,
+          true
+        );
+        for (const error of materialized.failures ?? [])
+          parseErrors.push(
+            initializerRuntimeDiagnostic(
+              error,
+              valueLowerRegistry.initializerSites,
+              sourceTextByUri,
+              projectAnalysisV4
+            )
+          );
+        const unavailableValueIds = new Set(rootValues.unavailableValueIds);
+        for (const id2 of materialized.unavailableRootIds ?? [])
+          unavailableValueIds.add(id2);
+        for (const [id2, site] of valueLowerRegistry.pendingValueIdentitySites) {
+          if (site.materializedLocation !== void 0 && materialized.unavailableRootIds?.has(
+            site.materializedLocation.rootId
+          ))
+            unavailableValueIds.add(id2);
+        }
+        for (const [id2, target] of materialized.resolvedLocalIds ?? []) {
+          const site = valueLowerRegistry.pendingValueIdentitySites.get(id2);
+          if (site !== void 0) {
+            valueLowerRegistry.pendingValueIdentitySites.delete(id2);
+            valueLowerRegistry.pendingValueIdentitySites.set(target, {
+              ...site,
+              id: target
+            });
+          }
+        }
+        valueLowerRegistry.localValues?.remapTargets(
+          materialized.resolvedLocalIds ?? /* @__PURE__ */ new Map()
+        );
+        const rewrite = createIdentityRewriter(
+          materialized.resolvedLocalIds ?? /* @__PURE__ */ new Map()
+        );
+        authoredValueSeeds = settleInitializerKeyCode({
+          settle: rewrite,
+          references: materialized.resolvedLocalIds,
+          seeds: authoredValueSeeds,
+          reconstructed: reconstructed3,
+          changes,
+          reconciliations: valueLowerRegistry.initializerReconciliations
+        });
+        if (deferredReferences.length > 0) {
+          const materializedState = { ...prospectiveState };
+          const pendingValues = new Map(valueLowerRegistry.pendingValues);
+          for (const root of materialized.roots) {
+            for (const row of root.rows) {
+              if (typeof row.id !== "string") continue;
+              pendingValues.delete(row.id);
+              materializedState[`value:${row.id}`] = {
+                recordKind: "value",
+                recordId: row.id,
+                contentHash: "",
+                data: row
+              };
+            }
+          }
+          const validationRegistry = { ...valueLowerRegistry, pendingValues };
+          const failures = drainValueReferenceObligationsV4(
+            materializedState,
+            manifest,
+            {
+              registry: validationRegistry,
+              analysis: projectAnalysisV4,
+              obligations: deferredReferences,
+              deletedValueIds,
+              unavailableReferenceMemberIds,
+              unavailableValueIds,
+              sourceTextByUri,
+              resolveRootPath: createRootValuePathResolverV4({
+                manifest,
+                state: materializedState,
+                resolveVirtualPath,
+                unavailableSlots: rootValues.unavailableSlots,
+                registry: validationRegistry,
+                initBuiltSlots: "refuse"
+              })
+            }
+          );
+          for (const failure of failures) {
+            parseErrors.push(
+              failure instanceof SchemaSourceError ? failure : new SchemaSourceError(
+                failure.message,
+                failure.file,
+                failure.line,
+                failure.column,
+                failure.code
+              )
+            );
+          }
+          if (failures.length > 0)
+            return refusedStatus(
+              conflictedFiles,
+              uniqueSourceErrors(parseErrors),
+              parseWarnings
+            );
+        }
+      } catch (error) {
+        const diagnostic = initializerRuntimeDiagnostic(
+          error,
+          valueLowerRegistry.initializerSites,
+          sourceTextByUri,
+          projectAnalysisV4
+        );
+        parseErrors.push(diagnostic);
+      }
+    } else {
+      const diagnostic = workspaceStatusInitializerDiagnostic(
+        workspace,
+        {
+          changes,
+          authoredValueSeeds,
+          pendingValueIdentitySites: valueLowerRegistry.pendingValueIdentitySites
+        },
+        valueLowerRegistry.initializerSites,
+        sourceTextByUri,
+        projectAnalysisV4,
+        options.forceRecompile
+      );
+      if (diagnostic !== null) parseErrors.push(diagnostic);
+    }
     reportPhase("initializer-materialization");
   }
   const dialogueBodyErrors = workspaceStatusDialogueBodyErrors(
@@ -182344,8 +183457,15 @@ function expandProspectiveAnimationInstances(document) {
 }
 function applyConstructionRebuildsV4(args) {
   if (args.rebuilds.length === 0) return;
+  const covered = /* @__PURE__ */ new Set();
+  for (const rebuild of args.rebuilds)
+    for (const id2 of rebuild.ownedValueIds)
+      if (id2 !== rebuild.valueId) covered.add(id2);
+  const roots = args.rebuilds.filter(
+    (rebuild) => !covered.has(rebuild.valueId)
+  );
   const replanned = /* @__PURE__ */ new Set();
-  for (const rebuild of args.rebuilds) {
+  for (const rebuild of roots) {
     for (const id2 of rebuild.ownedValueIds) {
       if (id2 === rebuild.valueId) continue;
       const key = recordStateKey("value", id2);
@@ -182370,7 +183490,7 @@ function applyConstructionRebuildsV4(args) {
     const key = recordStateKey(change.recordKind, change.recordId);
     if (!replanned.has(key)) output.set(key, change);
   }
-  for (const rebuild of args.rebuilds) {
+  for (const rebuild of roots) {
     const key = recordStateKey("value", rebuild.valueId);
     const base = args.workspace.state.records[key];
     if (base === void 0) {
@@ -183078,7 +184198,18 @@ function manifestRecordSources(manifest) {
   return result;
 }
 function settleInitializerKeyCode(args) {
+  const settleValue = (value) => {
+    if (args.references === void 0) return value;
+    if (typeof value === "string") return args.references.get(value) ?? value;
+    if (Array.isArray(value)) return value.map(settleValue);
+    if (!isObjectRecord(value)) return value;
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, settleValue(entry)])
+    );
+  };
   const settleInit = (data) => {
+    if ("value" in data && args.references !== void 0)
+      data = { ...data, value: settleValue(data.value) };
     const init = data.init;
     if (!isObjectRecord(init)) return data;
     if (typeof init.code !== "string") return data;
@@ -183096,10 +184227,17 @@ function settleInitializerKeyCode(args) {
   for (const [valueId, reconciliation] of args.reconciliations) {
     args.reconciliations.set(valueId, {
       ...reconciliation,
-      code: args.settle(reconciliation.code)
+      code: args.settle(reconciliation.code),
+      ...reconciliation.kind === "retainedLiteral" ? {} : { constructionCode: args.settle(reconciliation.constructionCode) }
     });
   }
-  const settleNode = (node) => node.nodeType === "initializer" ? { ...node, code: args.settle(node.code) } : node;
+  const settleNode = (node) => {
+    if (node.nodeType === "initializer")
+      return { ...node, code: args.settle(node.code) };
+    if (node.nodeType === "literal" && args.references !== void 0)
+      return { ...node, value: settleValue(node.value) };
+    return node;
+  };
   return new Map(
     Array.from(args.seeds, ([memberId, seed]) => [
       memberId,
@@ -183184,6 +184322,7 @@ var sourceSchemaValidation, pulledAnimationValues, animationCompilationProject,
 var init_workspace_status_core = __esm({
   "src/project-source/workspace-status-core.ts"() {
     "use strict";
+    init_identity_rewriter();
     init_initializer_replay();
     init_project_version_whole_graph_validation();
     init_record_fields();
@@ -183256,7 +184395,6 @@ var init_workspace_status_core = __esm({
     init_materialized_construction_cache();
     init_project_version_whole_graph_validation();
     init_value_base_desync();
-    init_inheritance();
     sourceSchemaValidation = createSchemaDocumentMemo();
     pulledAnimationValues = /* @__PURE__ */ new WeakMap();
     animationCompilationProject = createNeoScriptProjectMemo();
@@ -221675,7 +222813,7 @@ import {
   statSync as statSync7
 } from "node:fs";
 import { join as join22, relative as relative8, sep as sep9 } from "node:path";
-function assignPendingIds(changes, authoredValueSeeds, reconstructed3, previousLedger = {}) {
+function assignPendingIds(changes, authoredValueSeeds, reconstructed3, previousLedger = {}, codePendingIdCandidates = []) {
   const assigned = /* @__PURE__ */ new Map();
   const minted = /* @__PURE__ */ new Map();
   let mint = (pendingId2) => {
@@ -221686,6 +222824,14 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, previousL
   const assign = (pendingId2) => {
     const existing = assigned.get(pendingId2);
     if (existing !== void 0) return existing;
+    const genericArgument = pendingGenericArgumentIdentity(pendingId2);
+    if (genericArgument !== null) {
+      const parent = isPendingId(genericArgument.parentRecordId) ? assign(genericArgument.parentRecordId) : genericArgument.parentRecordId;
+      const parameter4 = isPendingId(genericArgument.genericParamId) ? assign(genericArgument.genericParamId) : genericArgument.genericParamId;
+      const derived = derivedGenericArgumentMemberId(parent, parameter4);
+      assigned.set(pendingId2, derived);
+      return derived;
+    }
     const pendingVirtual = pendingVirtualValueIdentity(pendingId2);
     if (pendingVirtual !== null) {
       const instanceRootId = isPendingId(pendingVirtual.instanceRootId) ? assign(pendingVirtual.instanceRootId) : pendingVirtual.instanceRootId;
@@ -221787,6 +222933,24 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, previousL
       collect(record7.fullData);
     }
   }
+  const codeCandidates = new Set(codePendingIdCandidates);
+  if (codeCandidates.size > 0) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const collectCodeIds = (value) => {
+      if (value === null || typeof value !== "object" || seen.has(value))
+        return;
+      seen.add(value);
+      for (const [key, entry] of Object.entries(value)) {
+        if (key === "code" && typeof entry === "string" && entry.includes(PENDING_ID_PREFIX)) {
+          for (const token of lex(entry).tokens)
+            if (token.value !== void 0 && codeCandidates.has(token.value))
+              collect(token.value);
+        } else collectCodeIds(entry);
+      }
+    };
+    for (const change of changes) collectCodeIds(change.nextData);
+    for (const seed of authoredValueSeeds.values()) collectCodeIds(seed);
+  }
   for (const root of roots) assign(root);
   const keys = identityLedgerKeys(minted.keys());
   const ledger = {};
@@ -222716,7 +223880,10 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
       status.changes,
       status.authoredValueSeeds,
       status.reconstructed,
-      { ...options.identityLedger, ...latestLedger }
+      { ...options.identityLedger, ...latestLedger },
+      [...status.pendingValueIdentitySites ?? []].flatMap(
+        ([id2, site]) => site.materializedLocation !== void 0 && pendingVirtualValueIdentity(id2) !== null ? [id2] : []
+      )
     );
     if (!mergeReservedIdentities(workspace.root, pendingAssignment.ledger)) {
       throw new Error(
@@ -222774,6 +223941,18 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
   let prepared;
   try {
     const preparationArgs2 = {
+      initializerReferenceOwners: new Map(
+        [...status.pendingValueIdentitySites ?? []].flatMap(
+          ([id2, site]) => site.materializedLocation === void 0 ? [] : [
+            [
+              pendingAssignment.assigned.get(id2) ?? id2,
+              pendingAssignment.assigned.get(
+                site.materializedLocation.rootId
+              ) ?? site.materializedLocation.rootId
+            ]
+          ]
+        )
+      ),
       scriptSources: new Map(
         [...status.scriptSources ?? []].map(([key, sources2]) => {
           const colon = key.indexOf(":");
@@ -224829,6 +226008,7 @@ var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
     init_local_project_file_storage();
+    init_generic_argument_member_id();
     init_extension_source_preservation();
     init_workspace_lock();
     init_export_state();
@@ -240314,7 +241494,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.89.7");
+    console.log("0.89.9");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {