@neocompose/cli 0.61.2 → 0.61.4

package/dist/neo.mjs

@@ -5112,8 +5112,8 @@ function pathRoot(path) {
   const dot = path.indexOf(".");
   return dot === -1 ? path : path.slice(0, dot);
 }
-function factsFromIsCheck(expression, whenTrue) {
-  const path = canonicalPath(expression.operand);
+function factsFromIsCheck(expression, whenTrue, pathOf) {
+  const path = pathOf(expression.operand);
   const nullCheck = expression.type.kind === "primitive" && expression.type.name === "null";
   if (path === null && (!whenTrue || nullCheck || !expression.bindingName)) {
     return [];
@@ -5137,58 +5137,72 @@ function extractNullCheckSide(expression) {
   if (!leftNull && !rightNull) return null;
   return leftNull ? expression.right : expression.left;
 }
-function factsWhenTrue(expression) {
-  if (expression.kind === "is") return factsFromIsCheck(expression, true);
+function pathsAfterBindings(pathOf, facts) {
+  const bindings = new Set(
+    facts.flatMap((fact) => fact.bindingName ? [fact.bindingName] : [])
+  );
+  if (bindings.size === 0) return pathOf;
+  return (expression) => {
+    const path = canonicalPath(expression);
+    return path !== null && bindings.has(pathRoot(path)) ? path : pathOf(expression);
+  };
+}
+function factsWhenTrue(expression, pathOf) {
+  if (expression.kind === "is")
+    return factsFromIsCheck(expression, true, pathOf);
   if (expression.kind === "binary") {
     if (expression.op === "&&") {
+      const left = factsWhenTrue(expression.left, pathOf);
       return [
-        ...factsWhenTrue(expression.left),
-        ...factsWhenTrue(expression.right)
+        ...left,
+        ...factsWhenTrue(expression.right, pathsAfterBindings(pathOf, left))
       ];
     }
     if (expression.op === "||") {
       return mergeFactSets([
-        factsWhenTrue(expression.left),
-        factsWhenTrue(expression.right)
+        factsWhenTrue(expression.left, pathOf),
+        factsWhenTrue(expression.right, pathOf)
       ]);
     }
     if (expression.op === "==" || expression.op === "!=") {
       const value = extractNullCheckSide(expression);
-      const path2 = value ? canonicalPath(value) : null;
+      const path2 = value ? pathOf(value) : null;
       return value && path2 ? [{ expression: value, path: path2, nullValue: expression.op === "==" }] : [];
     }
   }
   if (expression.kind === "unary" && expression.op === "!") {
-    return factsWhenFalse(expression.operand);
+    return factsWhenFalse(expression.operand, pathOf);
   }
-  const path = canonicalPath(expression);
+  const path = pathOf(expression);
   return path && (expression.kind === "ident" || expression.kind === "member") ? [{ expression, path, nullValue: false, loose: true }] : [];
 }
-function factsWhenFalse(expression) {
-  if (expression.kind === "is") return factsFromIsCheck(expression, false);
+function factsWhenFalse(expression, pathOf) {
+  if (expression.kind === "is")
+    return factsFromIsCheck(expression, false, pathOf);
   if (expression.kind === "binary") {
     if (expression.op === "||") {
+      const left = factsWhenFalse(expression.left, pathOf);
       return [
-        ...factsWhenFalse(expression.left),
-        ...factsWhenFalse(expression.right)
+        ...left,
+        ...factsWhenFalse(expression.right, pathsAfterBindings(pathOf, left))
       ];
     }
     if (expression.op === "&&") {
       return mergeFactSets([
-        factsWhenFalse(expression.left),
-        factsWhenFalse(expression.right)
+        factsWhenFalse(expression.left, pathOf),
+        factsWhenFalse(expression.right, pathOf)
       ]);
     }
     if (expression.op === "==" || expression.op === "!=") {
       const value = extractNullCheckSide(expression);
-      const path2 = value ? canonicalPath(value) : null;
+      const path2 = value ? pathOf(value) : null;
       return value && path2 ? [{ expression: value, path: path2, nullValue: expression.op !== "==" }] : [];
     }
   }
   if (expression.kind === "unary" && expression.op === "!") {
-    return factsWhenTrue(expression.operand);
+    return factsWhenTrue(expression.operand, pathOf);
   }
-  const path = canonicalPath(expression);
+  const path = pathOf(expression);
   return path && (expression.kind === "ident" || expression.kind === "member") ? [{ expression, path, nullValue: true, loose: true }] : [];
 }
 function mergeFactSets(sets) {
@@ -5350,156 +5364,440 @@ function scopeVariable(name, value, sourceType, writability, ownership, writeRoo
     ...readonlyBinding ? { readonlyBinding } : {}
   };
 }
-function invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements) {
-  for (const rootName of collectAssignedPathRoots(statements)) {
-    const outerEntry = outerScope.lookup(rootName);
-    if (outerEntry) {
-      loopEntryScope.hideInheritedNarrowing(outerEntry);
+function statementFlow(statements, cache) {
+  const cached = cache.get(statements);
+  if (cached) return cached;
+  const flow = /* @__PURE__ */ new Set(["fallthrough"]);
+  for (const statement of statements) {
+    if (!flow.delete("fallthrough")) break;
+    let next;
+    switch (statement.kind) {
+      case "return":
+      case "throw":
+        next = /* @__PURE__ */ new Set(["exit"]);
+        break;
+      case "break":
+        next = /* @__PURE__ */ new Set(["break"]);
+        break;
+      case "continue":
+        next = /* @__PURE__ */ new Set(["continue"]);
+        break;
+      case "if":
+        next = new Set(statementFlow(statement.elseBody ?? [], cache));
+        for (const branch of statement.branches)
+          for (const outcome of statementFlow(branch.body, cache))
+            next.add(outcome);
+        break;
+      case "try":
+        next = new Set(statementFlow(statement.body, cache));
+        for (const clause of statement.catches)
+          for (const outcome of statementFlow(clause.body, cache))
+            next.add(outcome);
+        break;
+      case "switch":
+        next = /* @__PURE__ */ new Set();
+        if (!statement.sections.some(
+          (section) => section.labels.some((label) => label.kind === "default")
+        )) {
+          next.add("fallthrough");
+        }
+        for (const section of statement.sections)
+          for (const outcome of statementFlow(section.body, cache))
+            next.add(outcome);
+        if (next.delete("break")) next.add("fallthrough");
+        break;
+      case "doWhile":
+        next = new Set(statementFlow(statement.body, cache));
+        if (next.delete("break")) next.add("fallthrough");
+        if (next.delete("continue")) next.add("fallthrough");
+        break;
+      default:
+        next = /* @__PURE__ */ new Set(["fallthrough"]);
+        break;
     }
+    for (const outcome of next) flow.add(outcome);
   }
+  cache.set(statements, flow);
+  return flow;
 }
-function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set()) {
+function localsWithBindings(locals, expression, whenTrue) {
+  const facts = whenTrue ? factsWhenTrue(expression, canonicalPath) : factsWhenFalse(expression, canonicalPath);
+  return /* @__PURE__ */ new Set([
+    ...locals,
+    ...facts.flatMap((fact) => fact.bindingName ? [fact.bindingName] : [])
+  ]);
+}
+function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(), inheritedLocals = /* @__PURE__ */ new Set(), flowCache = /* @__PURE__ */ new WeakMap()) {
+  const locals = new Set(inheritedLocals);
   for (const statement of statements) {
     if (statement.kind === "assign") {
       const assignedPath = canonicalPath(statement.target);
-      if (assignedPath) roots.add(pathRoot(assignedPath));
-      collectAssignedPathRootsInExpression(statement.target, roots);
+      if (assignedPath && !locals.has(pathRoot(assignedPath))) {
+        roots.add(pathRoot(assignedPath));
+      }
+      collectAssignedPathRootsInExpression(
+        statement.target,
+        roots,
+        locals,
+        flowCache
+      );
       if (statement.value)
-        collectAssignedPathRootsInExpression(statement.value, roots);
+        collectAssignedPathRootsInExpression(
+          statement.value,
+          roots,
+          locals,
+          flowCache
+        );
       continue;
     }
     if (statement.kind === "varDecl") {
-      collectAssignedPathRootsInExpression(statement.init, roots);
+      collectAssignedPathRootsInExpression(
+        statement.init,
+        roots,
+        locals,
+        flowCache
+      );
+      locals.add(statement.name);
       continue;
     }
     if (statement.kind === "if") {
+      let falseLocals = locals;
+      const falseFacts = [];
+      const fallthroughFacts = [];
       for (const branch of statement.branches) {
-        collectAssignedPathRootsInExpression(branch.cond, roots);
-        collectAssignedPathRoots(branch.body, roots);
+        collectAssignedPathRootsInExpression(
+          branch.cond,
+          roots,
+          falseLocals,
+          flowCache
+        );
+        const branchFacts = [
+          ...falseFacts,
+          ...factsWhenTrue(branch.cond, canonicalPath)
+        ];
+        collectAssignedPathRoots(
+          branch.body,
+          roots,
+          localsWithBindings(falseLocals, branch.cond, true),
+          flowCache
+        );
+        if (statementFlow(branch.body, flowCache).has("fallthrough"))
+          fallthroughFacts.push(branchFacts);
+        falseFacts.push(...factsWhenFalse(branch.cond, canonicalPath));
+        falseLocals = localsWithBindings(falseLocals, branch.cond, false);
       }
       if (statement.elseBody) {
-        collectAssignedPathRoots(statement.elseBody, roots);
+        collectAssignedPathRoots(
+          statement.elseBody,
+          roots,
+          falseLocals,
+          flowCache
+        );
+        if (statementFlow(statement.elseBody, flowCache).has("fallthrough"))
+          fallthroughFacts.push(falseFacts);
+      } else {
+        fallthroughFacts.push(falseFacts);
+      }
+      for (const fact of mergeFactSets(fallthroughFacts)) {
+        if (fact.bindingName) locals.add(fact.bindingName);
       }
       continue;
     }
     if (statement.kind === "try") {
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRoots(statement.body, roots, locals, flowCache);
       for (const clause of statement.catches) {
+        const catchLocals = /* @__PURE__ */ new Set([...locals, clause.name]);
         if (clause.filter) {
-          collectAssignedPathRootsInExpression(clause.filter, roots);
+          collectAssignedPathRootsInExpression(
+            clause.filter,
+            roots,
+            catchLocals,
+            flowCache
+          );
         }
-        collectAssignedPathRoots(clause.body, roots);
+        collectAssignedPathRoots(
+          clause.body,
+          roots,
+          clause.filter ? localsWithBindings(catchLocals, clause.filter, true) : catchLocals,
+          flowCache
+        );
       }
       continue;
     }
     if (statement.kind === "while" || statement.kind === "doWhile") {
-      collectAssignedPathRootsInExpression(statement.condition, roots);
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRootsInExpression(
+        statement.condition,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRoots(
+        statement.body,
+        roots,
+        statement.kind === "while" ? localsWithBindings(locals, statement.condition, true) : locals,
+        flowCache
+      );
       continue;
     }
     if (statement.kind === "for") {
-      collectAssignedPathRootsInExpression(statement.initializer.init, roots);
-      collectAssignedPathRootsInExpression(statement.condition, roots);
-      collectAssignedPathRoots([statement.iterator], roots);
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRootsInExpression(
+        statement.initializer.init,
+        roots,
+        locals,
+        flowCache
+      );
+      const loopLocals = /* @__PURE__ */ new Set([...locals, statement.initializer.name]);
+      collectAssignedPathRootsInExpression(
+        statement.condition,
+        roots,
+        loopLocals,
+        flowCache
+      );
+      const iterationLocals = localsWithBindings(
+        loopLocals,
+        statement.condition,
+        true
+      );
+      collectAssignedPathRoots(
+        [statement.iterator],
+        roots,
+        iterationLocals,
+        flowCache
+      );
+      collectAssignedPathRoots(
+        statement.body,
+        roots,
+        iterationLocals,
+        flowCache
+      );
       continue;
     }
     if (statement.kind === "forEach") {
-      collectAssignedPathRootsInExpression(statement.collection, roots);
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRootsInExpression(
+        statement.collection,
+        roots,
+        locals,
+        flowCache
+      );
+      const loopLocals = /* @__PURE__ */ new Set([...locals, statement.name]);
+      if (statement.key) loopLocals.add(statement.key.name);
+      collectAssignedPathRoots(statement.body, roots, loopLocals, flowCache);
       continue;
     }
     if (statement.kind === "switch") {
-      collectAssignedPathRootsInExpression(statement.selector, roots);
+      collectAssignedPathRootsInExpression(
+        statement.selector,
+        roots,
+        locals,
+        flowCache
+      );
       for (const section of statement.sections) {
         for (const label of section.labels) {
           if (label.kind === "case") {
-            collectAssignedPathRootsInExpression(label.expression, roots);
+            collectAssignedPathRootsInExpression(
+              label.expression,
+              roots,
+              locals,
+              flowCache
+            );
           }
         }
-        collectAssignedPathRoots(section.body, roots);
+        collectAssignedPathRoots(section.body, roots, locals, flowCache);
       }
       continue;
     }
     if (statement.kind === "return" || statement.kind === "throw") {
       if (statement.expr)
-        collectAssignedPathRootsInExpression(statement.expr, roots);
+        collectAssignedPathRootsInExpression(
+          statement.expr,
+          roots,
+          locals,
+          flowCache
+        );
       continue;
     }
     if (statement.kind === "exprStmt") {
-      collectAssignedPathRootsInExpression(statement.expr, roots);
+      collectAssignedPathRootsInExpression(
+        statement.expr,
+        roots,
+        locals,
+        flowCache
+      );
     }
   }
   return roots;
 }
-function collectAssignedPathRootsInExpression(expression, roots) {
+function collectAssignedPathRootsInExpression(expression, roots, locals, flowCache) {
   switch (expression.kind) {
     case "litInterp":
       for (const part of expression.parts) {
         if (part.kind === "expr") {
-          collectAssignedPathRootsInExpression(part.expr, roots);
+          collectAssignedPathRootsInExpression(
+            part.expr,
+            roots,
+            locals,
+            flowCache
+          );
         }
       }
       return;
     case "litList":
       for (const element of expression.elements) {
-        collectAssignedPathRootsInExpression(element, roots);
+        collectAssignedPathRootsInExpression(element, roots, locals, flowCache);
       }
       return;
     case "litDict":
       for (const entry of expression.entries) {
-        collectAssignedPathRootsInExpression(entry.key, roots);
-        collectAssignedPathRootsInExpression(entry.value, roots);
+        collectAssignedPathRootsInExpression(
+          entry.key,
+          roots,
+          locals,
+          flowCache
+        );
+        collectAssignedPathRootsInExpression(
+          entry.value,
+          roots,
+          locals,
+          flowCache
+        );
       }
       return;
     case "member":
-      collectAssignedPathRootsInExpression(expression.receiver, roots);
+      collectAssignedPathRootsInExpression(
+        expression.receiver,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "index":
-      collectAssignedPathRootsInExpression(expression.receiver, roots);
-      collectAssignedPathRootsInExpression(expression.index, roots);
+      collectAssignedPathRootsInExpression(
+        expression.receiver,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.index,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "call":
-      collectAssignedPathRootsInExpression(expression.callee, roots);
+      collectAssignedPathRootsInExpression(
+        expression.callee,
+        roots,
+        locals,
+        flowCache
+      );
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(argument2, roots);
+        collectAssignedPathRootsInExpression(
+          argument2,
+          roots,
+          locals,
+          flowCache
+        );
       }
       return;
     case "new":
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(argument2, roots);
+        collectAssignedPathRootsInExpression(
+          argument2,
+          roots,
+          locals,
+          flowCache
+        );
       }
       for (const initializer of expression.initializer ?? []) {
-        collectAssignedPathRootsInExpression(initializer.value, roots);
+        collectAssignedPathRootsInExpression(
+          initializer.value,
+          roots,
+          locals,
+          flowCache
+        );
       }
       return;
     case "annotated":
       for (const annotation2 of expression.annotations) {
         for (const argument2 of annotation2.args) {
-          collectAssignedPathRootsInExpression(argument2, roots);
+          collectAssignedPathRootsInExpression(
+            argument2,
+            roots,
+            locals,
+            flowCache
+          );
         }
       }
-      collectAssignedPathRootsInExpression(expression.expression, roots);
+      collectAssignedPathRootsInExpression(
+        expression.expression,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "binary":
     case "coalesce":
-      collectAssignedPathRootsInExpression(expression.left, roots);
-      collectAssignedPathRootsInExpression(expression.right, roots);
+      collectAssignedPathRootsInExpression(
+        expression.left,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.right,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "conditional":
-      collectAssignedPathRootsInExpression(expression.condition, roots);
-      collectAssignedPathRootsInExpression(expression.whenTrue, roots);
-      collectAssignedPathRootsInExpression(expression.whenFalse, roots);
+      collectAssignedPathRootsInExpression(
+        expression.condition,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.whenTrue,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.whenFalse,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "unary":
     case "force":
-      collectAssignedPathRootsInExpression(expression.operand, roots);
+      collectAssignedPathRootsInExpression(
+        expression.operand,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "is":
-      collectAssignedPathRootsInExpression(expression.operand, roots);
+      collectAssignedPathRootsInExpression(
+        expression.operand,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "lambda":
-      collectAssignedPathRoots(expression.body, roots);
+      collectAssignedPathRoots(
+        expression.body,
+        roots,
+        /* @__PURE__ */ new Set([
+          ...locals,
+          ...expression.params.map((parameter4) => parameter4.name)
+        ]),
+        flowCache
+      );
       return;
     case "litNull":
     case "litBool":
@@ -6846,16 +7144,18 @@ var init_strict_resolver = __esm({
               const child = new Scope(scope);
               const branchFacts = [
                 ...cumulativeFalseFacts,
-                ...factsWhenTrue(branch.cond)
+                ...this.conditionFacts(branch.cond, scope, true)
               ];
-              this.applyFactsToScope(scope, child, branchFacts);
+              this.applyFactsToScope(child, branchFacts);
               const instructions = this.resolveStatements(branch.body, child);
               if (!instructionsTerminate(instructions)) {
                 branchExitFacts.push(branchFacts);
                 branchExitNarrowings.push(new Map(child.narrowedPaths));
                 branchExitOwnershipScopes.push(child);
               }
-              cumulativeFalseFacts.push(...factsWhenFalse(branch.cond));
+              cumulativeFalseFacts.push(
+                ...this.conditionFacts(branch.cond, scope, false)
+              );
               return {
                 expression: pointerToBooleanExpression(condition.pointer),
                 instructions
@@ -6864,7 +7164,7 @@ var init_strict_resolver = __esm({
             let otherwise = null;
             if (statement.elseBody) {
               const elseScope = new Scope(scope);
-              this.applyFactsToScope(scope, elseScope, cumulativeFalseFacts);
+              this.applyFactsToScope(elseScope, cumulativeFalseFacts);
               otherwise = this.resolveStatements(statement.elseBody, elseScope);
               if (!instructionsTerminate(otherwise)) {
                 branchExitFacts.push([...cumulativeFalseFacts]);
@@ -6873,7 +7173,7 @@ var init_strict_resolver = __esm({
               }
             } else {
               const noBranchScope = new Scope(scope);
-              this.applyFactsToScope(scope, noBranchScope, cumulativeFalseFacts);
+              this.applyFactsToScope(noBranchScope, cumulativeFalseFacts);
               branchExitFacts.push([...cumulativeFalseFacts]);
               branchExitNarrowings.push(new Map(noBranchScope.narrowedPaths));
               branchExitOwnershipScopes.push(noBranchScope);
@@ -6891,7 +7191,6 @@ var init_strict_resolver = __esm({
             }
             mergeBranchOwnership(scope, branchExitOwnershipScopes);
             this.applyFactsToScope(
-              scope,
               scope,
               mergeFactSets(branchExitFacts),
               "bindings-only"
@@ -7001,10 +7300,11 @@ var init_strict_resolver = __esm({
           case "while":
           case "doWhile": {
             const loopScope = new Scope(scope);
-            invalidateLoopEntryNarrowingsAssignedBy(
+            this.invalidateLoopEntryNarrowingsAssignedBy(
               loopScope,
               scope,
-              statement.body
+              statement.body,
+              statement.kind === "while" ? localsWithBindings(/* @__PURE__ */ new Set(), statement.condition, true) : /* @__PURE__ */ new Set()
             );
             const iterationScope = new Scope(loopScope);
             let condition;
@@ -7013,8 +7313,8 @@ var init_strict_resolver = __esm({
                 this.resolveExpression(statement.condition, loopScope),
                 statement.condition.pos
               );
-              this.applyFactsToScope(loopScope, iterationScope, [
-                ...factsWhenTrue(statement.condition)
+              this.applyFactsToScope(iterationScope, [
+                ...this.conditionFacts(statement.condition, loopScope, true)
               ]);
             }
             const bodyScope = new Scope(iterationScope);
@@ -7051,15 +7351,19 @@ var init_strict_resolver = __esm({
               );
             }
             const normalExitScope = new Scope(nextConditionScope);
-            this.applyFactsToScope(nextConditionScope, normalExitScope, [
-              ...factsWhenFalse(statement.condition)
+            this.applyFactsToScope(normalExitScope, [
+              ...this.conditionFacts(
+                statement.condition,
+                nextConditionScope,
+                false
+              )
             ]);
             const effectScopes = nextConditionEffects.length > 0 ? [nextConditionScope] : [];
             const exitNarrowings = nextConditionEffects.length > 0 ? [normalExitScope.effectiveNarrowedPaths()] : [];
             if (statement.kind === "while") {
               const initialExitScope = new Scope(loopScope);
-              this.applyFactsToScope(loopScope, initialExitScope, [
-                ...factsWhenFalse(statement.condition)
+              this.applyFactsToScope(initialExitScope, [
+                ...this.conditionFacts(statement.condition, loopScope, false)
               ]);
               effectScopes.push(loopScope);
               exitNarrowings.push(initialExitScope.effectiveNarrowedPaths());
@@ -7087,17 +7391,30 @@ var init_strict_resolver = __esm({
               );
             }
             const loopEntryScope = new Scope(loopScope);
-            invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, scope, [
-              ...statement.body,
-              statement.iterator
-            ]);
+            const conditionLocals = localsWithBindings(
+              /* @__PURE__ */ new Set(),
+              statement.condition,
+              true
+            );
+            this.invalidateLoopEntryNarrowingsAssignedBy(
+              loopEntryScope,
+              loopScope,
+              statement.body,
+              conditionLocals
+            );
+            this.invalidateLoopEntryNarrowingsAssignedBy(
+              loopEntryScope,
+              loopScope,
+              [statement.iterator],
+              conditionLocals
+            );
             const condition = this.toBool(
               this.resolveExpression(statement.condition, loopEntryScope),
               statement.condition.pos
             );
             const iterationScope = new Scope(loopEntryScope);
-            this.applyFactsToScope(loopEntryScope, iterationScope, [
-              ...factsWhenTrue(statement.condition)
+            this.applyFactsToScope(iterationScope, [
+              ...this.conditionFacts(statement.condition, loopEntryScope, true)
             ]);
             const bodyScope = new Scope(iterationScope);
             const loopFlow = {
@@ -7133,8 +7450,8 @@ var init_strict_resolver = __esm({
               );
             }
             const initialConditionFalseScope = new Scope(loopScope);
-            this.applyFactsToScope(loopScope, initialConditionFalseScope, [
-              ...factsWhenFalse(statement.condition)
+            this.applyFactsToScope(initialConditionFalseScope, [
+              ...this.conditionFacts(statement.condition, loopScope, false)
             ]);
             const effectScopes = [loopScope];
             const normalExitScopes = [initialConditionFalseScope];
@@ -7145,11 +7462,13 @@ var init_strict_resolver = __esm({
               ]);
               effectScopes.push(postIterationScope);
               const subsequentConditionFalseScope = new Scope(postIterationScope);
-              this.applyFactsToScope(
-                postIterationScope,
-                subsequentConditionFalseScope,
-                [...factsWhenFalse(statement.condition)]
-              );
+              this.applyFactsToScope(subsequentConditionFalseScope, [
+                ...this.conditionFacts(
+                  statement.condition,
+                  postIterationScope,
+                  false
+                )
+              ]);
               normalExitScopes.push(subsequentConditionFalseScope);
             }
             this.mergeLoopEffects(scope, effectScopes, loopFlow.breakEffects);
@@ -7269,9 +7588,9 @@ var init_strict_resolver = __esm({
               });
             }
             const iterationScope = new Scope(loopScope);
-            invalidateLoopEntryNarrowingsAssignedBy(
+            this.invalidateLoopEntryNarrowingsAssignedBy(
               iterationScope,
-              scope,
+              loopScope,
               statement.body
             );
             const bodyScope = new Scope(iterationScope);
@@ -7563,8 +7882,8 @@ var init_strict_resolver = __esm({
         }
         const bodyScope = new Scope(catchScope);
         if (clause.filter) {
-          this.applyFactsToScope(catchScope, bodyScope, [
-            ...factsWhenTrue(clause.filter)
+          this.applyFactsToScope(bodyScope, [
+            ...this.conditionFacts(clause.filter, catchScope, true)
           ]);
         }
         const catchPointer = {
@@ -7857,7 +8176,10 @@ var init_strict_resolver = __esm({
             value.writability ?? "runtime" /* Runtime */
           );
         }
-        const assignedPath = canonicalPath(statement.target);
+        const assignedPath = this.narrowingPath(
+          canonicalPath(statement.target),
+          scope
+        );
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
           if (rootEntry) {
@@ -7896,7 +8218,20 @@ var init_strict_resolver = __esm({
        * lookup `resolveMember` performs before it overlays a narrowed type.
        */
       assignmentStorageType(targetAst, resolvedTarget, local, scope) {
-        if (targetAst.kind === "ident") return local?.type ?? resolvedTarget.type;
+        if (targetAst.kind === "ident") {
+          if (local) return local.type;
+          const path = this.narrowingPath(targetAst.name, scope);
+          if (path === `this.${targetAst.name}`) {
+            return this.resolveMemberNatural(
+              { kind: "ident", name: "this", pos: targetAst.pos },
+              targetAst.name,
+              scope,
+              targetAst.pos,
+              false
+            ).type;
+          }
+          return resolvedTarget.type;
+        }
         if (targetAst.kind !== "member") return resolvedTarget.type;
         return this.resolveMemberNatural(
           targetAst.receiver,
@@ -7957,7 +8292,10 @@ var init_strict_resolver = __esm({
           actionType,
           scope
         );
-        const assignedPath = canonicalPath(statement.target);
+        const assignedPath = this.narrowingPath(
+          canonicalPath(statement.target),
+          scope
+        );
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
           if (rootEntry) {
@@ -9108,11 +9446,42 @@ var init_strict_resolver = __esm({
           pos
         );
       }
-      applyFactsToScope(outerScope, targetScope, facts, mode = "all") {
+      narrowingPath(path, scope) {
+        if (path === null) return null;
+        const root = pathRoot(path);
+        if (scope.lookup(root)) return path;
+        if (this.context.project.globals.some((symbol) => symbol.name === root)) {
+          return path;
+        }
+        const implicit = this.implicitMember(root);
+        return implicit && implicit.symbol.static !== true ? `this.${path}` : path;
+      }
+      conditionFacts(expression, scope, whenTrue) {
+        const pathOf = (value) => this.narrowingPath(canonicalPath(value), scope);
+        return whenTrue ? factsWhenTrue(expression, pathOf) : factsWhenFalse(expression, pathOf);
+      }
+      /**
+       * A loop body is resolved once but can execute repeatedly. Any narrowing rooted
+       * in an outer binding that the body or iterator may write is therefore stale
+       * at a later iteration entry. Invalidate those roots before resolving the
+       * shared iteration so only the loop's own condition can narrow them again.
+       */
+      invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements, locals = /* @__PURE__ */ new Set()) {
+        for (const rootName of collectAssignedPathRoots(
+          statements,
+          /* @__PURE__ */ new Set(),
+          locals
+        )) {
+          const path = this.narrowingPath(rootName, outerScope);
+          const outerEntry = path === null ? null : outerScope.lookup(pathRoot(path));
+          if (outerEntry) loopEntryScope.hideInheritedNarrowing(outerEntry);
+        }
+      }
+      applyFactsToScope(targetScope, facts, mode = "all") {
         for (const fact of facts) {
           if (mode === "bindings-only" && !fact.bindingName) continue;
-          const natural = this.resolveExpression(fact.expression, outerScope);
-          const rootEntry = fact.path === null ? null : outerScope.lookup(pathRoot(fact.path));
+          const natural = this.resolveExpression(fact.expression, targetScope);
+          const rootEntry = fact.path === null ? null : targetScope.lookup(pathRoot(fact.path));
           if (fact.nullValue) {
             if (fact.path === null || rootEntry === null) continue;
             if (fact.loose === true && natural.type.kind === "primitive" && (natural.type.name === "string" || natural.type.name === "int" || natural.type.name === "float" || natural.type.name === "bool")) {
@@ -9418,7 +9787,10 @@ var init_strict_resolver = __esm({
           optional2
         );
         if (!optional2) {
-          const receiverPath = canonicalPath(receiverAst);
+          const receiverPath = this.narrowingPath(
+            canonicalPath(receiverAst),
+            scope
+          );
           if (receiverPath) {
             const rootEntry = scope.lookup(pathRoot(receiverPath));
             if (rootEntry) {
@@ -12507,7 +12879,10 @@ var init_strict_resolver = __esm({
           scope,
           true
         );
-        const path = canonicalPath(expression.callee.receiver);
+        const path = this.narrowingPath(
+          canonicalPath(expression.callee.receiver),
+          scope
+        );
         if (path) {
           const rootEntry = scope.lookup(pathRoot(path));
           if (rootEntry) scope.invalidate(rootEntry);
@@ -12568,15 +12943,13 @@ var init_strict_resolver = __esm({
         );
         const trueScope = new Scope(scope);
         this.applyFactsToScope(
-          scope,
           trueScope,
-          factsWhenTrue(expression.condition)
+          this.conditionFacts(expression.condition, scope, true)
         );
         const falseScope = new Scope(scope);
         this.applyFactsToScope(
-          scope,
           falseScope,
-          factsWhenFalse(expression.condition)
+          this.conditionFacts(expression.condition, scope, false)
         );
         let whenTrue;
         let whenFalse;
@@ -12658,9 +13031,8 @@ var init_strict_resolver = __esm({
         if (expression.op === "&&" || expression.op === "||") {
           rightScope = new Scope(scope);
           this.applyFactsToScope(
-            scope,
             rightScope,
-            expression.op === "&&" ? factsWhenTrue(expression.left) : factsWhenFalse(expression.left)
+            expression.op === "&&" ? this.conditionFacts(expression.left, scope, true) : this.conditionFacts(expression.left, scope, false)
           );
         }
         const right = preResolvedRight ?? this.resolveExpression(expression.right, rightScope, left.type);
@@ -35212,9 +35584,14 @@ var init_service = __esm({
           if (state.context.projectSourceKind !== "spec") continue;
           const snapshot = this.scriptSnapshot(state);
           for (const candidate of snapshot.parsed.references) {
-            if (resolveReferenceSymbolId(snapshot, candidate) !== declaration.id) {
-              continue;
-            }
+            if (candidate.name !== declaration.name) continue;
+            const symbolId = resolveReferenceSymbolId(snapshot, candidate);
+            if (symbolId === null) continue;
+            const matches = declaration.id !== null ? symbolId === declaration.id : sameLocationInList(
+              declaration.location,
+              definition(snapshot, candidate.range.start)
+            );
+            if (!matches) continue;
             locations.push({ uri: state.document.uri, range: candidate.range });
           }
         }
@@ -63084,6 +63461,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 +76138,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 +86131,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 +88520,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 +88529,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 +88649,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 +98722,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 +99760,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 +101058,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 +101489,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 +103937,11 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     prepared,
     contentHashHeads: args.contentHashHeads
   });
+  materializePreparedCollectionBindings({
+    document: args.document,
+    prepared,
+    contentHashHeads: args.contentHashHeads
+  });
   drainConstructedGraphValidations({
     document: args.document,
     prepared,
@@ -106840,6 +107432,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 +121400,8 @@ function resolveRootPathCollectionValuesV4(args) {
       args.registry,
       placements,
       rootValues,
-      fail2
+      fail2,
+      args.resolveVirtualPath
     );
     if (target !== null) resolved.set(member.id, target);
   }
@@ -120845,7 +121439,8 @@ function resolveRootPathVariantFolderCollectionValuesV4(args) {
       args.registry,
       placements,
       rootValues,
-      fail2
+      fail2,
+      args.resolveVirtualPath
     );
     if (target !== null) resolved.set(folder.id, target);
   }
@@ -120882,7 +121477,8 @@ function resolveRootPathDialogueGroupCollectionValuesV4(args) {
           expression: null,
           label: String(record6.fileFields.name)
         }
-      })
+      }),
+      args.resolveVirtualPath
     );
     if (target !== null) record6.fileFields.collectionValueId = target;
   }
@@ -120902,7 +121498,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 +121541,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 +121621,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 +123238,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 +123295,7 @@ function computeWorkspaceStatus(workspace, options) {
   const resolvedVariantFolderPaths = resolveRootPathVariantFolderCollectionValuesV4({
     manifest,
     state: rootPathResolutionState,
+    resolveVirtualPath,
     registry: valueLowerRegistry,
     siteForFolder: (folderId) => {
       const span2 = sourceByKey.get(
@@ -122753,7 +123382,7 @@ function computeWorkspaceStatus(workspace, options) {
       }
     }
   }
-  const rootRecords = rootValues.records;
+  const rootRecords = [...rootValues.records];
   const variantValues = lowerVariantValueSourcesV4(
     loweringRecords,
     manifest,
@@ -122769,8 +123398,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 +124845,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 +127518,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 +127903,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 +132148,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 +133816,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 +146399,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.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -154383,7 +155079,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.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {