@neocompose/cli 0.61.2 → 0.61.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.61.3] - 2026-10-01
+
+- Resolve `collectionValue: Reference(root.Assets.Quests.Daily)` through construction defaults, including classes and empty collections declared in the same push. Preparation creates the required rows and associations together; no preliminary push or manually assigned value IDs are needed.
+- Preserve generated collection identities through source verification and subsequent pulls. Report one source diagnostic when a collection path cannot resolve.
+- Capture root-path reads through construction defaults as executable initializers, including nested object fields. Preserve sparse receiver identities during read-only construction replay so local and web preparation can resolve those reads.
+
 ## [0.61.2] - 2026-09-30
 
 - Delete hidden collection entry members when their owning class or collection declaration is removed or changed to a scalar, while preserving entries still used by surviving declarations.

package/dist/neo.mjs

@@ -63084,6 +63084,7 @@ function isSourceMemberValueRead(context, expression, ownerClass) {
   while (current.kind === "annotated") current = current.expression;
   const path = expressionMemberPath(current);
   if (path === null) return false;
+  if (path.startsWith("root.")) return true;
   const parts = path.split(".");
   let classId;
   let memberName;
@@ -75760,7 +75761,7 @@ function withEvaluationRuntime(ctx, writes) {
     ctx.__runtimeSessionValues
   );
   const referencesAlreadyRemapped = ctx.__valueOverlay !== void 0 && ctx.__runtimeReferenceRemap !== void 0;
-  const remap = (value) => referencesAlreadyRemapped ? value : remapRuntimeReferences(
+  const remap = (value) => referencesAlreadyRemapped || ctx.storedConstructionReplay === true ? value : remapRuntimeReferences(
     value,
     overlay,
     referenceRemap,
@@ -85753,14 +85754,15 @@ function claimVirtualIdentity(args) {
       virtualId: args.fixedVirtualId
     };
   }
-  const derivedId = virtualValueId(args.instanceRootId, args.rawSourceIdentity);
+  const valueId = (sourceIdentity4) => args.instanceRootId.startsWith("__pending__:") || hasPendingVirtualSourceIdentity(sourceIdentity4) ? pendingVirtualValueId(args.instanceRootId, sourceIdentity4) : virtualValueId(args.instanceRootId, sourceIdentity4);
+  const derivedId = valueId(args.rawSourceIdentity);
   const claimedPath = args.claimedVirtualIds.get(derivedId);
   if (claimedPath === void 0 || claimedPath === args.pathKey) {
     args.claimedVirtualIds.set(derivedId, args.pathKey);
     return { sourceIdentity: args.rawSourceIdentity, virtualId: derivedId };
   }
   const sourceIdentity3 = `${args.rawSourceIdentity}:${args.pathKey}`;
-  const virtualId = virtualValueId(args.instanceRootId, sourceIdentity3);
+  const virtualId = valueId(sourceIdentity3);
   args.claimedVirtualIds.set(virtualId, args.pathKey);
   return { sourceIdentity: sourceIdentity3, virtualId };
 }
@@ -88141,6 +88143,8 @@ function createHeadlessVirtualInstanceResolver(args) {
   const remember = (graph, rows) => {
     graphRowsByRootId.set(graph.instanceRootId, rows);
     for (const [id2, row] of graph.rowsById) {
+      if (id2 !== graph.instanceRootId && graphByValueId.get(id2)?.instanceRootId === id2)
+        continue;
       expandedRowById.set(id2, row);
       graphByValueId.set(id2, graph);
       if (typeof row.value === "object" && row.value !== null) {
@@ -88148,6 +88152,8 @@ function createHeadlessVirtualInstanceResolver(args) {
       }
     }
     for (const id2 of graph.locationsById.keys()) {
+      if (id2 !== graph.instanceRootId && graphByValueId.get(id2)?.instanceRootId === id2)
+        continue;
       graphByValueId.set(id2, graph);
     }
     graphByValueId.set(graph.instanceRootId, graph);
@@ -88266,7 +88272,10 @@ function createHeadlessVirtualInstanceResolver(args) {
     rowForValueReference: (value) => expandedRowByRecord.get(value) ?? null,
     virtualInstanceGraphForValue: (valueId) => {
       const known = graphByValueId.get(valueId);
-      if (known !== void 0) return known;
+      if (known?.instanceRootId === valueId) return known;
+      const stored = rawById.get(valueId);
+      if (known !== void 0 && (stored === void 0 || !isStoredClassResolutionRoot(stored)))
+        return known;
       virtualInstanceRowsForValue(valueId);
       return graphByValueId.get(valueId) ?? null;
     },
@@ -98336,6 +98345,389 @@ var init_project_commit_preparation_scoped_loader = __esm({
   }
 });
 
+// ../src/runtime/neoscript/index.ts
+var init_neoscript2 = __esm({
+  "../src/runtime/neoscript/index.ts"() {
+    "use strict";
+    init_NSGetterRuntimeError();
+    init_evaluateNSGetter();
+    init_evaluateInitializer();
+    init_initializer_context();
+  }
+});
+
+// ../src/database/headless-virtual-instance-lookups.ts
+function headlessVirtualInstanceLookups(document, options = {}) {
+  const members = document.members;
+  const expandedDocument = expandPackedDocumentValues(document);
+  const values = expandedDocument.values;
+  const indexed = makeEvaluatorLookups(
+    members,
+    values,
+    options.includeValueGraphIndexes === true ? {
+      includeValueGraphIndexes: true,
+      constructorInitializerDocument: {
+        classes: document.classes,
+        members,
+        values
+      }
+    } : {}
+  );
+  const virtual = createHeadlessVirtualInstanceResolver2({
+    document: {
+      ...expandedDocument,
+      ...options.initializerCompiler === void 0 ? {} : { initializerCompiler: options.initializerCompiler }
+    },
+    // A thunk: the resolver resolves nested reads through the lookups being
+    // built around it.
+    resolverLookups: () => lookups
+  });
+  const lookups = {
+    ...indexed,
+    // Raw first, then virtual: a materialized row always wins over the
+    // expansion that would otherwise answer for it.
+    valueById: (id2) => indexed.valueById(id2) ?? virtual.valueById(id2),
+    rowForValueReference: (value) => indexed.rowForValueReference(value) ?? virtual.rowForValueReference(value),
+    virtualInstanceRowsForValue: (receiverValueId) => virtual.virtualInstanceRowsForValue(receiverValueId),
+    // Stored-construction replay evaluates `ToVariant`, and production's
+    // variant-constructed placements collapse through exactly this path.
+    resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument2({
+      document,
+      resolverLookups: lookups,
+      ...args
+    }),
+    // A write to a virtual key must MATERIALIZE it (a pin row at the
+    // deterministic virtual id plus the sparse spine); the planner needs the
+    // owning graph, not just its rows.
+    virtualInstanceGraphForValue: (valueId) => virtual.virtualInstanceGraphForValue(valueId)
+  };
+  return lookups;
+}
+var init_headless_virtual_instance_lookups = __esm({
+  "../src/database/headless-virtual-instance-lookups.ts"() {
+    "use strict";
+    init_virtual_instance_values();
+    init_packed_value_encoding();
+    init_neoscript2();
+  }
+});
+
+// ../src/database/collection-binding-materialization.ts
+function mergeBodies(left, right) {
+  if (right === void 0) return left;
+  if (typeof left === "object" && left !== null && !Array.isArray(left) && typeof right === "object" && right !== null && !Array.isArray(right)) {
+    return { ...left, ...right };
+  }
+  return right;
+}
+var CollectionBindingMaterializer;
+var init_collection_binding_materialization = __esm({
+  "../src/database/collection-binding-materialization.ts"() {
+    "use strict";
+    init_members();
+    init_virtual_instance_values();
+    init_headless_virtual_instance_lookups();
+    init_document_initializer_compiler();
+    CollectionBindingMaterializer = class {
+      constructor(document) {
+        this.document = document;
+        this.stored = new Map(document.values.map((row) => [row.id, row]));
+        this.lookups = headlessVirtualInstanceLookups(document, {
+          initializerCompiler: documentInitializerCompiler(document)
+        });
+      }
+      document;
+      rows = /* @__PURE__ */ new Map();
+      pathRowsByRootId = /* @__PURE__ */ new Map();
+      stored;
+      lookups;
+      resolvePath(rootId, segments) {
+        let id2 = rootId;
+        const pathRows = this.pathRowsByRootId.get(rootId) ?? /* @__PURE__ */ new Set();
+        this.pathRowsByRootId.set(rootId, pathRows);
+        for (const segment of segments) {
+          const graph = this.lookups.virtualInstanceGraphForValue(id2);
+          const row = graph?.rowsById.get(id2) ?? this.stored.get(id2);
+          if (row === void 0 || !isLiteralValueContent(row)) return null;
+          const body = row.value;
+          if (typeof body !== "object" || body === null || Array.isArray(body))
+            return null;
+          const next = Reflect.get(body, segment);
+          if (typeof next !== "string") return null;
+          id2 = next;
+          pathRows.add(id2);
+        }
+        return this.materialize(id2, pathRows) ? id2 : null;
+      }
+      /** Discover opaque virtual IDs from web selections against this candidate's roots. */
+      materializeTargets(ids) {
+        const missing = new Set([...ids].filter((id2) => !this.stored.has(id2)));
+        if (missing.size === 0) return;
+        const visited = /* @__PURE__ */ new Set();
+        for (const row of this.document.values) {
+          if (typeof row.classId !== "string") continue;
+          const graph = this.lookups.virtualInstanceGraphForValue(row.id);
+          if (graph === null || visited.has(graph.instanceRootId)) continue;
+          visited.add(graph.instanceRootId);
+          for (const id2 of graph.rowsById.keys()) {
+            if (!missing.has(id2)) continue;
+            if (this.materialize(id2)) missing.delete(id2);
+          }
+          if (missing.size === 0) return;
+        }
+        if (missing.size > 0) {
+          throw new Error(
+            `Collection binding targets missing values: ${[...missing].join(", ")}.`
+          );
+        }
+      }
+      locationForValue(id2) {
+        return this.lookups.virtualInstanceGraphForValue(id2)?.locationsById.get(id2);
+      }
+      rowForValue(id2) {
+        return this.rows.get(id2) ?? this.stored.get(id2);
+      }
+      materialize(id2, pathRows) {
+        if (this.stored.has(id2) || this.rows.has(id2)) return true;
+        const graph = this.lookups.virtualInstanceGraphForValue(id2);
+        const row = graph?.rowsById.get(id2);
+        if (graph === null || row === void 0 || !isLiteralValueContent(row))
+          return false;
+        const plan = planVirtualOverrideWrite({
+          graph,
+          valueId: id2,
+          value: row.value
+        });
+        for (const create of plan.creates) {
+          pathRows?.add(create.id);
+          const { valuePlacement: _placement, ...fields } = create;
+          const previous = this.rows.get(create.id);
+          this.rows.set(create.id, {
+            ...fields,
+            value: mergeBodies(fields.value, previous?.value),
+            projectId: this.document.project.id,
+            createdAt: 0,
+            updatedAt: 0
+          });
+        }
+        for (const update of plan.updates) {
+          pathRows?.add(update.valueId);
+          const previous = this.rows.get(update.valueId) ?? this.stored.get(update.valueId);
+          if (previous === void 0)
+            throw new Error(
+              `Collection binding has no ancestor ${update.valueId}.`
+            );
+          this.rows.set(update.valueId, {
+            ...previous,
+            value: mergeBodies(previous.value, update.value)
+          });
+        }
+        return true;
+      }
+    };
+  }
+});
+
+// ../src/database/project-version-write-changes.ts
+function applyProjectVersionWriteChanges(document, changes) {
+  return projectVersionDocumentWithChanges(document, changes, false);
+}
+function projectVersionDocumentWithChanges(document, changes, reuseUnchangedBuckets) {
+  const projectRows = (rows, kind) => {
+    const relevant = changes.filter((change) => change.recordKind === kind);
+    if (reuseUnchangedBuckets && relevant.length === 0) return rows;
+    return applyArrayChanges(rows, relevant);
+  };
+  const hasGranularDialogueRecords = document.dialogueRecords !== void 0 || changes.some((change) => change.recordKind === "dialogue");
+  const hasGranularDialogueNodes = document.dialogueNodes !== void 0 || changes.some((change) => change.recordKind === "dialogue-node");
+  const dialogueRecords = hasGranularDialogueRecords ? projectRows(document.dialogueRecords ?? [], "dialogue") : void 0;
+  const dialogueNodes = hasGranularDialogueNodes ? projectRows(document.dialogueNodes ?? [], "dialogue-node") : void 0;
+  const projected = {
+    localizedTexts: projectRows(
+      document.localizedTexts ?? [],
+      "localized-text"
+    ),
+    localizationConfig: applySingletonChange(
+      document.localizationConfig,
+      changes,
+      "localization-config"
+    ),
+    project: applySingletonChange(document.project, changes, "project"),
+    members: projectRows(document.members, "member"),
+    classes: projectRows(document.classes, "class"),
+    // P43 §6. Declared constructors participate in the post-transaction
+    // document so the whole-graph validator and every body compile see the
+    // same constructor surface the transaction is about to persist.
+    constructors: projectRows(document.constructors ?? [], "constructor"),
+    // P67 §2.1. Same reason as constructors: without these buckets the
+    // whole-graph validator, the variant ownership roots, and every body
+    // compile would grade the transaction against the pre-transaction
+    // variant set — so a newly pushed variant's closures would compile
+    // against a document that does not contain it.
+    variants: projectRows(document.variants ?? [], "variant"),
+    variantFolders: projectRows(
+      document.variantFolders ?? [],
+      "variant-folder"
+    ),
+    values: projectRows(document.values ?? [], "value"),
+    // Project-file staging finalizes pending uploads before schema
+    // preparation. Defaults and authored instance graphs may reference a file
+    // created by the same source transaction, so every construction pass must
+    // see that finalized row in its post-write document.
+    projectFiles: projectRows(document.projectFiles ?? [], "project-file"),
+    // Import-setting templates are part of the same file graph. A new file
+    // may select a new template in one source transaction, and default-value
+    // materialization validates that relationship immediately against this
+    // post-write document.
+    textureTemplates: projectRows(
+      document.textureTemplates ?? [],
+      "unity-texture-template"
+    ),
+    audioClipTemplates: projectRows(
+      document.audioClipTemplates ?? [],
+      "unity-audio-clip-template"
+    ),
+    internalRecordRelations: projectRows(
+      document.internalRecordRelations ?? [],
+      "internal-record-relation"
+    ),
+    enums: projectRows(document.enums, "enum"),
+    interfaces: projectRows(document.interfaces, "interface"),
+    dialogues: dialogueRecords === void 0 || dialogueNodes === void 0 || dialogueRecords === document.dialogueRecords && dialogueNodes === document.dialogueNodes ? document.dialogues : materializeDialogues(
+      dialogueRecords,
+      dialogueNodes
+    ),
+    dialogueGroups: projectRows(
+      document.dialogueGroups ?? [],
+      "dialogue-group"
+    ),
+    migrations: projectRows(document.migrations ?? [], "migration")
+  };
+  return {
+    ...document,
+    ...projected,
+    ...dialogueRecords === void 0 ? {} : { dialogueRecords },
+    ...dialogueNodes === void 0 ? {} : { dialogueNodes }
+    // The document spread above carries every bucket the caller's view declares
+    // beyond the projected ones, so the result is the same view; TypeScript
+    // cannot prove that of an object literal built over a type parameter.
+  };
+}
+function applySingletonChange(current, changes, recordKind) {
+  const change = changes.find(
+    (candidate) => candidate.recordKind === recordKind
+  );
+  if (change === void 0) return current;
+  if (change.operation === "delete" || change.nextData === void 0) {
+    throw new Error(`Schema commit cannot delete the ${recordKind} record.`);
+  }
+  return change.nextData;
+}
+function applyArrayChanges(current, changes) {
+  const byId = new Map(current.map((record6) => [record6.id, record6]));
+  for (const change of changes) {
+    if (change.operation === "delete") {
+      byId.delete(change.recordId);
+      continue;
+    }
+    if (change.nextData !== void 0) {
+      byId.set(change.recordId, change.nextData);
+    }
+  }
+  return [...byId.values()];
+}
+var init_project_version_write_changes = __esm({
+  "../src/database/project-version-write-changes.ts"() {
+    "use strict";
+    init_projectDocumentDialogueMaterialization();
+  }
+});
+
+// ../src/database/prepared-collection-bindings.ts
+function materializePreparedCollectionBindings(args) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const change of args.prepared) {
+    if (change.operation === "delete") continue;
+    if (change.recordKind !== "member" && change.recordKind !== "variant-folder" && change.recordKind !== "dialogue-group")
+      continue;
+    const data = change.nextData;
+    if (typeof data !== "object" || data === null) continue;
+    const binding = change.recordKind === "variant-folder" ? Reflect.get(data, "binding") : data;
+    if (typeof binding !== "object" || binding === null) continue;
+    const id2 = Reflect.get(binding, "collectionValueId");
+    if (typeof id2 === "string") targets.add(id2);
+  }
+  if (targets.size === 0) return;
+  const deletedTargets = /* @__PURE__ */ new Set();
+  for (const change of args.prepared) {
+    if (change.recordKind !== "value" || !targets.has(change.recordId))
+      continue;
+    if (change.operation === "delete") deletedTargets.add(change.recordId);
+    else targets.delete(change.recordId);
+  }
+  if (targets.size === 0) return;
+  for (const row of args.document.values) {
+    if (!deletedTargets.has(row.id)) targets.delete(row.id);
+    if (targets.size === 0) return;
+  }
+  const document = projectVersionDocumentWithChanges(
+    args.document,
+    args.prepared,
+    true
+  );
+  const existingIds = new Set(document.values.map((row) => row.id));
+  const materializer = new CollectionBindingMaterializer(document);
+  materializer.materializeTargets(targets);
+  const indexes2 = /* @__PURE__ */ new Map();
+  args.prepared.forEach((change, index) => {
+    if (change.recordKind === "value") indexes2.set(change.recordId, index);
+  });
+  const hashes = new Map(
+    args.contentHashHeads.filter((head) => head.recordKind === "value").map((head) => [head.recordId, head.contentHash])
+  );
+  for (const row of materializer.rows.values()) {
+    const index = indexes2.get(row.id);
+    if (index !== void 0) {
+      const previous = args.prepared[index];
+      args.prepared[index] = {
+        ...previous,
+        operation: previous.operation === "delete" ? "update" : previous.operation,
+        deleted: false,
+        nextData: row,
+        intent: previous.operation === "delete" ? createProjectVersionIntent("value.update", {
+          source: "collection-binding-materialization"
+        }) : previous.intent
+      };
+      continue;
+    }
+    const contentHash = hashes.get(row.id);
+    if (existingIds.has(row.id) && contentHash === void 0) {
+      throw new Error(
+        `Collection binding ancestor "${row.id}" has no content hash.`
+      );
+    }
+    args.prepared.push({
+      recordKind: "value",
+      recordId: row.id,
+      operation: existingIds.has(row.id) ? "update" : "create",
+      nextData: row,
+      expectedBaseContentHash: contentHash ?? null,
+      intent: createProjectVersionIntent(
+        existingIds.has(row.id) ? "value.update" : "value.create",
+        { source: "collection-binding-materialization" }
+      )
+    });
+  }
+}
+var init_prepared_collection_bindings = __esm({
+  "../src/database/prepared-collection-bindings.ts"() {
+    "use strict";
+    init_project_version_intents();
+    init_collection_binding_materialization();
+    init_project_version_write_changes();
+  }
+});
+
 // ../src/models/project/world-content-sidecar-validation.ts
 function cachedWorldLayerTarget(context, args) {
   let target = context.linkTargetsByClassId.get(args.sourceClassId);
@@ -98991,17 +99383,6 @@ var init_world_content_sidecar_validation = __esm({
   }
 });
 
-// ../src/runtime/neoscript/index.ts
-var init_neoscript2 = __esm({
-  "../src/runtime/neoscript/index.ts"() {
-    "use strict";
-    init_NSGetterRuntimeError();
-    init_evaluateNSGetter();
-    init_evaluateInitializer();
-    init_initializer_context();
-  }
-});
-
 // ../src/database/dialogue-node-index.ts
 function indexDialogueNodesByDialogue(nodes, dialogueId) {
   const result = /* @__PURE__ */ new Map();
@@ -100300,62 +100681,6 @@ var init_general_function_call_ir_source_recompile = __esm({
   }
 });
 
-// ../src/database/headless-virtual-instance-lookups.ts
-function headlessVirtualInstanceLookups(document, options = {}) {
-  const members = document.members;
-  const expandedDocument = expandPackedDocumentValues(document);
-  const values = expandedDocument.values;
-  const indexed = makeEvaluatorLookups(
-    members,
-    values,
-    options.includeValueGraphIndexes === true ? {
-      includeValueGraphIndexes: true,
-      constructorInitializerDocument: {
-        classes: document.classes,
-        members,
-        values
-      }
-    } : {}
-  );
-  const virtual = createHeadlessVirtualInstanceResolver2({
-    document: {
-      ...expandedDocument,
-      ...options.initializerCompiler === void 0 ? {} : { initializerCompiler: options.initializerCompiler }
-    },
-    // A thunk: the resolver resolves nested reads through the lookups being
-    // built around it.
-    resolverLookups: () => lookups
-  });
-  const lookups = {
-    ...indexed,
-    // Raw first, then virtual: a materialized row always wins over the
-    // expansion that would otherwise answer for it.
-    valueById: (id2) => indexed.valueById(id2) ?? virtual.valueById(id2),
-    rowForValueReference: (value) => indexed.rowForValueReference(value) ?? virtual.rowForValueReference(value),
-    virtualInstanceRowsForValue: (receiverValueId) => virtual.virtualInstanceRowsForValue(receiverValueId),
-    // Stored-construction replay evaluates `ToVariant`, and production's
-    // variant-constructed placements collapse through exactly this path.
-    resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument2({
-      document,
-      resolverLookups: lookups,
-      ...args
-    }),
-    // A write to a virtual key must MATERIALIZE it (a pin row at the
-    // deterministic virtual id plus the sparse spine); the planner needs the
-    // owning graph, not just its rows.
-    virtualInstanceGraphForValue: (valueId) => virtual.virtualInstanceGraphForValue(valueId)
-  };
-  return lookups;
-}
-var init_headless_virtual_instance_lookups = __esm({
-  "../src/database/headless-virtual-instance-lookups.ts"() {
-    "use strict";
-    init_virtual_instance_values();
-    init_packed_value_encoding();
-    init_neoscript2();
-  }
-});
-
 // ../src/database/localized-instance-override-writes.ts
 function collapseEditedLocalizedInstanceOverrides(args) {
   const edits = args.changes.filter(
@@ -100787,121 +101112,6 @@ var init_member_access_modifier_validation = __esm({
   }
 });
 
-// ../src/database/project-version-write-changes.ts
-function applyProjectVersionWriteChanges(document, changes) {
-  return projectVersionDocumentWithChanges(document, changes, false);
-}
-function projectVersionDocumentWithChanges(document, changes, reuseUnchangedBuckets) {
-  const projectRows = (rows, kind) => {
-    const relevant = changes.filter((change) => change.recordKind === kind);
-    if (reuseUnchangedBuckets && relevant.length === 0) return rows;
-    return applyArrayChanges(rows, relevant);
-  };
-  const hasGranularDialogueRecords = document.dialogueRecords !== void 0 || changes.some((change) => change.recordKind === "dialogue");
-  const hasGranularDialogueNodes = document.dialogueNodes !== void 0 || changes.some((change) => change.recordKind === "dialogue-node");
-  const dialogueRecords = hasGranularDialogueRecords ? projectRows(document.dialogueRecords ?? [], "dialogue") : void 0;
-  const dialogueNodes = hasGranularDialogueNodes ? projectRows(document.dialogueNodes ?? [], "dialogue-node") : void 0;
-  const projected = {
-    localizedTexts: projectRows(
-      document.localizedTexts ?? [],
-      "localized-text"
-    ),
-    localizationConfig: applySingletonChange(
-      document.localizationConfig,
-      changes,
-      "localization-config"
-    ),
-    project: applySingletonChange(document.project, changes, "project"),
-    members: projectRows(document.members, "member"),
-    classes: projectRows(document.classes, "class"),
-    // P43 §6. Declared constructors participate in the post-transaction
-    // document so the whole-graph validator and every body compile see the
-    // same constructor surface the transaction is about to persist.
-    constructors: projectRows(document.constructors ?? [], "constructor"),
-    // P67 §2.1. Same reason as constructors: without these buckets the
-    // whole-graph validator, the variant ownership roots, and every body
-    // compile would grade the transaction against the pre-transaction
-    // variant set — so a newly pushed variant's closures would compile
-    // against a document that does not contain it.
-    variants: projectRows(document.variants ?? [], "variant"),
-    variantFolders: projectRows(
-      document.variantFolders ?? [],
-      "variant-folder"
-    ),
-    values: projectRows(document.values ?? [], "value"),
-    // Project-file staging finalizes pending uploads before schema
-    // preparation. Defaults and authored instance graphs may reference a file
-    // created by the same source transaction, so every construction pass must
-    // see that finalized row in its post-write document.
-    projectFiles: projectRows(document.projectFiles ?? [], "project-file"),
-    // Import-setting templates are part of the same file graph. A new file
-    // may select a new template in one source transaction, and default-value
-    // materialization validates that relationship immediately against this
-    // post-write document.
-    textureTemplates: projectRows(
-      document.textureTemplates ?? [],
-      "unity-texture-template"
-    ),
-    audioClipTemplates: projectRows(
-      document.audioClipTemplates ?? [],
-      "unity-audio-clip-template"
-    ),
-    internalRecordRelations: projectRows(
-      document.internalRecordRelations ?? [],
-      "internal-record-relation"
-    ),
-    enums: projectRows(document.enums, "enum"),
-    interfaces: projectRows(document.interfaces, "interface"),
-    dialogues: dialogueRecords === void 0 || dialogueNodes === void 0 || dialogueRecords === document.dialogueRecords && dialogueNodes === document.dialogueNodes ? document.dialogues : materializeDialogues(
-      dialogueRecords,
-      dialogueNodes
-    ),
-    dialogueGroups: projectRows(
-      document.dialogueGroups ?? [],
-      "dialogue-group"
-    ),
-    migrations: projectRows(document.migrations ?? [], "migration")
-  };
-  return {
-    ...document,
-    ...projected,
-    ...dialogueRecords === void 0 ? {} : { dialogueRecords },
-    ...dialogueNodes === void 0 ? {} : { dialogueNodes }
-    // The document spread above carries every bucket the caller's view declares
-    // beyond the projected ones, so the result is the same view; TypeScript
-    // cannot prove that of an object literal built over a type parameter.
-  };
-}
-function applySingletonChange(current, changes, recordKind) {
-  const change = changes.find(
-    (candidate) => candidate.recordKind === recordKind
-  );
-  if (change === void 0) return current;
-  if (change.operation === "delete" || change.nextData === void 0) {
-    throw new Error(`Schema commit cannot delete the ${recordKind} record.`);
-  }
-  return change.nextData;
-}
-function applyArrayChanges(current, changes) {
-  const byId = new Map(current.map((record6) => [record6.id, record6]));
-  for (const change of changes) {
-    if (change.operation === "delete") {
-      byId.delete(change.recordId);
-      continue;
-    }
-    if (change.nextData !== void 0) {
-      byId.set(change.recordId, change.nextData);
-    }
-  }
-  return [...byId.values()];
-}
-var init_project_version_write_changes = __esm({
-  "../src/database/project-version-write-changes.ts"() {
-    "use strict";
-    init_projectDocumentDialogueMaterialization();
-  }
-});
-
 // ../src/database/member-localization-normalization.ts
 function planMemberLocalizationNormalization(input, now = 0) {
   const before = expandPackedDocumentValues(input);
@@ -103350,6 +103560,11 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     prepared,
     contentHashHeads: args.contentHashHeads
   });
+  materializePreparedCollectionBindings({
+    document: args.document,
+    prepared,
+    contentHashHeads: args.contentHashHeads
+  });
   drainConstructedGraphValidations({
     document: args.document,
     prepared,
@@ -106840,6 +107055,7 @@ var SERVER_COMPILATION_PROJECT_CACHE_LIMIT, serverCompilationProjectCache, READ_
 var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
+    init_prepared_collection_bindings();
     init_document_initializer_compiler();
     init_effective_value_comparison();
     init_classes();
@@ -120807,7 +121023,8 @@ function resolveRootPathCollectionValuesV4(args) {
       args.registry,
       placements,
       rootValues,
-      fail2
+      fail2,
+      args.resolveVirtualPath
     );
     if (target !== null) resolved.set(member.id, target);
   }
@@ -120845,7 +121062,8 @@ function resolveRootPathVariantFolderCollectionValuesV4(args) {
       args.registry,
       placements,
       rootValues,
-      fail2
+      fail2,
+      args.resolveVirtualPath
     );
     if (target !== null) resolved.set(folder.id, target);
   }
@@ -120882,7 +121100,8 @@ function resolveRootPathDialogueGroupCollectionValuesV4(args) {
           expression: null,
           label: String(record6.fileFields.name)
         }
-      })
+      }),
+      args.resolveVirtualPath
     );
     if (target !== null) record6.fileFields.collectionValueId = target;
   }
@@ -120902,7 +121121,7 @@ function rootSlotValueIds(state) {
   });
   return values;
 }
-function walkRootValuePath(path, state, registry, placements, rootValues, fail2) {
+function walkRootValuePath(path, state, registry, placements, rootValues, fail2, resolveVirtualPath) {
   const segments = path.split(".");
   const slotName = segments[1];
   if (segments[0] !== "root" || slotName === void 0) {
@@ -120945,10 +121164,17 @@ function walkRootValuePath(path, state, registry, placements, rootValues, fail2)
     }
     const next = placements.childrenByParentValueId.get(cursor)?.get(segment)?.childValueId;
     if (typeof next !== "string") {
-      const cursorData = state[`value:${cursor}`]?.data;
-      const collapsed = isObjectRecord2(cursorData) && isVirtualInstanceRootShape(cursorData);
+      try {
+        const resolved = resolveVirtualPath?.(slotValueId, segments.slice(2));
+        if (resolved != null) return resolved;
+      } catch (error) {
+        fail2(
+          `collectionValue path ${path} could not resolve its construction: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return null;
+      }
       fail2(
-        collapsed ? `collectionValue path ${path} reaches segment ${segment} on a collapsed instance "${cursor}": the value exists in that instance's construction but has no stored row to bind, and this push cannot materialize one. Name the row with Reference(id: ...) instead.` : `collectionValue path ${path} has no value at segment ${segment} after this push.`
+        `collectionValue path ${path} has no value at segment ${segment} after this push.`
       );
       return null;
     }
@@ -121018,7 +121244,6 @@ var init_root_source = __esm({
     "use strict";
     init_src();
     init_src2();
-    init_instance_provenance();
     init_value_sources();
     init_source_format();
     init_stored_value_placements();
@@ -122636,9 +122861,35 @@ function computeWorkspaceStatus(workspace, options) {
     [...staticValues.records, ...memberDefaults.records, ...rootValues.records],
     staticMemberValueIds
   );
+  let collectionBindings;
+  const resolveVirtualPath = (rootId, segments) => {
+    if (collectionBindings === void 0) {
+      const candidate = /* @__PURE__ */ new Map();
+      for (const [key, record6] of Object.entries(rootPathResolutionState)) {
+        if (record6.file !== void 0 && isSchemaRecordKindV4(record6.recordKind) && !documentsByKey.has(key))
+          continue;
+        candidate.set(key, { ...record6, deleted: false });
+      }
+      for (const row of valueLowerRegistry.pendingValues.values()) {
+        candidate.set(`value:${row.id}`, {
+          recordKind: "value",
+          recordId: row.id,
+          contentHash: "",
+          deleted: false,
+          data: { id: row.id, ...encodeStoredValueRowFields(row) }
+        });
+      }
+      const document = readPulledProjectDocumentV4(candidate);
+      compilePulledProjectDocumentForEvaluationV4(document);
+      collectionBindings = new CollectionBindingMaterializer(document);
+    }
+    const resolved = collectionBindings.resolvePath(rootId, segments);
+    return resolved;
+  };
   const resolvedCollectionPaths = resolveRootPathCollectionValuesV4({
     manifest,
     state: rootPathResolutionState,
+    resolveVirtualPath,
     registry: valueLowerRegistry,
     siteForMember: (memberId) => {
       const span2 = sourceByKey.get(recordStateKey("member", memberId))?.span;
@@ -122667,6 +122918,7 @@ function computeWorkspaceStatus(workspace, options) {
   const resolvedVariantFolderPaths = resolveRootPathVariantFolderCollectionValuesV4({
     manifest,
     state: rootPathResolutionState,
+    resolveVirtualPath,
     registry: valueLowerRegistry,
     siteForFolder: (folderId) => {
       const span2 = sourceByKey.get(
@@ -122753,7 +123005,7 @@ function computeWorkspaceStatus(workspace, options) {
       }
     }
   }
-  const rootRecords = rootValues.records;
+  const rootRecords = [...rootValues.records];
   const variantValues = lowerVariantValueSourcesV4(
     loweringRecords,
     manifest,
@@ -122769,8 +123021,71 @@ function computeWorkspaceStatus(workspace, options) {
     records: supplementalRecords,
     manifest,
     state: rootPathResolutionState,
+    resolveVirtualPath,
     registry: valueLowerRegistry
   });
+  if (collectionBindings !== void 0) {
+    const bindingSeeds = new Map(authoredValueSeeds);
+    const rootRecordsById = new Map(
+      rootRecords.filter((record6) => record6.recordKind === "value").map((record6) => [record6.recordId, record6])
+    );
+    const rootMembers = /* @__PURE__ */ new Map();
+    for (const record6 of Object.values(rootPathResolutionState)) {
+      if (record6.recordKind === "member" && isObjectRecord2(record6.data) && typeof record6.data.valueId === "string")
+        rootMembers.set(record6.data.valueId, record6.recordId);
+    }
+    for (const row of collectionBindings.rows.values()) {
+      if (rootPathResolutionState[`value:${row.id}`] === void 0) continue;
+      const existing = rootRecordsById.get(row.id);
+      if (existing !== void 0) Object.assign(existing.fileFields, row);
+      else
+        rootRecords.push({
+          recordKind: "value",
+          recordId: row.id,
+          file: "Root.neo",
+          line: 1,
+          fileFields: { ...row }
+        });
+    }
+    for (const [rootId, rowIds] of collectionBindings.pathRowsByRootId) {
+      const memberId = rootMembers.get(rootId);
+      const root = collectionBindings.rowForValue(rootId);
+      if (memberId === void 0 || root === void 0) continue;
+      const seed = authoredValueSeeds.get(memberId);
+      const rows = new Map((seed?.values ?? []).map((row) => [row.id, row]));
+      for (const id2 of rowIds) {
+        if (id2 === rootId) continue;
+        const row = collectionBindings.rowForValue(id2);
+        const location3 = collectionBindings.locationForValue(id2);
+        if (row === void 0 || !isLiteralValueContent(row) || location3 === void 0)
+          throw new Error(`Collection binding row ${id2} has no member.`);
+        const isNew = rootPathResolutionState[`value:${id2}`] === void 0;
+        const classId = row.classId ?? (isMemberClassBase(location3.member) ? location3.member.classId : null);
+        const authored = staticValueSeedRow(
+          {
+            ...row,
+            classId,
+            ...isNew && classId !== null ? {
+              constructorArgs: row.constructorArgs ?? {},
+              instanceConstructorId: row.instanceConstructorId ?? null
+            } : {}
+          },
+          location3.memberId
+        );
+        rows.set(id2, authored);
+        if (isNew) valueLowerRegistry.pendingValues.set(id2, authored);
+      }
+      bindingSeeds.set(memberId, {
+        ...seed,
+        nodeType: "literal",
+        valueId: rootId,
+        value: root.value,
+        classId: root.classId ?? null,
+        values: [...rows.values()]
+      });
+    }
+    authoredValueSeeds = bindingSeeds;
+  }
   const prospectiveState = overlayProspectiveSourceRecords(
     loweringRecords,
     documents,
@@ -124153,6 +124468,8 @@ var ANIMATION_DOCUMENT_RECORD_KINDS, ANIMATION_REPLAY_RECORD_KINDS, PROSPECTIVE_
 var init_workspace_status_core = __esm({
   "src/project-source/workspace-status-core.ts"() {
     "use strict";
+    init_members();
+    init_collection_binding_materialization();
     init_localizable_member_value_writes();
     init_localized_instance_override_writes();
     init_localization2();
@@ -126824,6 +127141,7 @@ function collectionValueObligations(manifest) {
   for (const member of manifest.members) {
     if (member.kind !== "lookup") continue;
     if (typeof member.collectionValueId !== "string") continue;
+    if (member.collectionValueId.startsWith("__pending__:root-path:")) continue;
     obligations.push({
       kind: "collectionValue",
       site: {
@@ -127208,6 +127526,7 @@ function memberInitializerRequiresEvaluation(context, member, expression, source
 function isSchemaMemberValueRead(context, expression, source) {
   const path = memberPath2(annotatedValue(expression).expression);
   if (path === null) return false;
+  if (path.startsWith("root.")) return true;
   const parts = path.split(".");
   const name = parts.at(-1);
   if (name === void 0) return false;
@@ -131452,10 +131771,9 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
       `${key} = ${emitValue(context, emittedChildMember, childId, {
         environment,
         definitionSite: !context.symbolsByValueId.has(childId),
-        // A class slot recovers this row from the owning value and schema key.
-        // P61 creation metadata and localization back-pointers must not turn
-        // that structural child into an explicitly identified source value.
-        writeIdentity: false,
+        // Existing slots recover identity from storage. A newly pinned virtual
+        // slot must keep its derived pending identity through repeat lowering.
+        writeIdentity: pendingVirtualValueIdentity(childId) !== null,
         visited
       })}`
     );
@@ -133121,6 +133439,7 @@ var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, M
 var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
+    init_member_value_id();
     init_effective_value_comparison();
     init_member_declared_type_info();
     init_constructor_argument_ownership();
@@ -145703,7 +146022,7 @@ var init_registry2 = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.61.2",
+      cliVersion: "0.61.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -154383,7 +154702,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.61.2");
+    console.log("0.61.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.61.2",
+  "version": "0.61.3",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.61.2 -->
+<!-- reviewed-through-cli: 0.61.3 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -110,7 +110,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.61.2 -->
+<!-- reviewed-through-cli: 0.61.3 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/declarations-and-construction.md

@@ -219,6 +219,10 @@ qualified static, or reached through a stable root path. For example,
 `protected int Slots = FeatureFlags.StartInventorySize;` evaluates the current
 static field or getter whenever a new instance is constructed; it is not baked
 into a persisted literal during push.
+Root paths such as `root.Save.World.Time.Year` remain executable even when
+`World` and `Time` exist only through construction defaults. This also applies
+inside `new() { Year = root.Save.World.Time.Year }`: the child field retains
+its initializer and reads the root when the instance is constructed.
 
 Declare overloadable constructors as members when each constructor body owns
 its parameter scope:

package/skills/neocompose-cli/references/values-identities-and-references.md

@@ -130,7 +130,11 @@ the edit is not a target, and lookup/dialogue references must still satisfy
 assignability, collection membership, multiplicity, and group constraints.
 
 `collectionValue` references follow the same post-push resolution and
-membership rules as member defaults.
+membership rules as member defaults. Name the collection itself, for example
+`Reference(root.Assets.Quests.Daily)`. A path may traverse construction defaults
+and declarations created in the same push. Preparation materializes the target
+collection and its required ancestor rows together, preserving the virtual
+identities. No preliminary push or manual value ID is needed.
 
 ## Defaults and localization