@neocompose/cli 0.72.2 → 0.72.4

package/dist/test-worker.mjs

@@ -33780,14 +33780,17 @@ var Scope = class {
     return this.invalidatedRoots;
   }
   effectiveNarrowedPaths() {
-    const effective = this.parent ? new Map(this.parent.effectiveNarrowedPaths()) : /* @__PURE__ */ new Map();
-    for (const invalidated of this.invalidatedRoots) {
-      for (const [path, narrowed] of effective) {
-        if (narrowed.rootEntry === invalidated) effective.delete(path);
+    const effective = new Map(this.narrowedPaths);
+    const invalidated = new Set(this.invalidatedRoots);
+    for (const root of this.hiddenNarrowingRoots) invalidated.add(root);
+    for (let current = this.parent; current; current = current.parent) {
+      for (const [path, narrowed] of current.narrowedPaths) {
+        if (!effective.has(path) && !invalidated.has(narrowed.rootEntry)) {
+          effective.set(path, narrowed);
+        }
       }
-    }
-    for (const [path, narrowed] of this.narrowedPaths) {
-      effective.set(path, narrowed);
+      for (const root of current.invalidatedRoots) invalidated.add(root);
+      for (const root of current.hiddenNarrowingRoots) invalidated.add(root);
     }
     return effective;
   }
@@ -33813,6 +33816,9 @@ var Scope = class {
   hideInheritedNarrowing(rootEntry) {
     this.hiddenNarrowingRoots.add(rootEntry);
     this.updatePatternType(rootEntry, rootEntry.type);
+    for (const [path, narrowed] of this.narrowedPaths) {
+      if (narrowed.rootEntry === rootEntry) this.narrowedPaths.delete(path);
+    }
   }
   invalidate(rootEntry) {
     this.invalidatedRoots.add(rootEntry);
@@ -34370,24 +34376,26 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const branchExitNarrowings = [];
         const branchExitOwnershipScopes = [];
         const branches = statement.branches.map((branch) => {
+          const conditionScope = new Scope(scope);
+          this.applyFactsToScope(conditionScope, cumulativeFalseFacts);
           const condition = this.toBool(
-            this.resolveExpression(branch.cond, scope),
+            this.resolveExpression(branch.cond, conditionScope),
             branch.cond.pos
           );
           const child = new Scope(scope);
           const branchFacts = [
             ...cumulativeFalseFacts,
-            ...this.conditionFacts(branch.cond, scope, true)
+            ...this.conditionFacts(branch.cond, conditionScope, true)
           ];
           this.applyFactsToScope(child, branchFacts);
           const instructions = this.resolveStatements(branch.body, child);
           if (!instructionsTerminate(instructions)) {
             branchExitFacts.push(branchFacts);
-            branchExitNarrowings.push(new Map(child.narrowedPaths));
+            branchExitNarrowings.push(child.effectiveNarrowedPaths());
             branchExitOwnershipScopes.push(child);
           }
           cumulativeFalseFacts.push(
-            ...this.conditionFacts(branch.cond, scope, false)
+            ...this.conditionFacts(branch.cond, conditionScope, false)
           );
           return {
             expression: pointerToBooleanExpression(condition.pointer),
@@ -34401,14 +34409,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           otherwise = this.resolveStatements(statement.elseBody, elseScope);
           if (!instructionsTerminate(otherwise)) {
             branchExitFacts.push([...cumulativeFalseFacts]);
-            branchExitNarrowings.push(new Map(elseScope.narrowedPaths));
+            branchExitNarrowings.push(elseScope.effectiveNarrowedPaths());
             branchExitOwnershipScopes.push(elseScope);
           }
         } else {
           const noBranchScope = new Scope(scope);
           this.applyFactsToScope(noBranchScope, cumulativeFalseFacts);
           branchExitFacts.push([...cumulativeFalseFacts]);
-          branchExitNarrowings.push(new Map(noBranchScope.narrowedPaths));
+          branchExitNarrowings.push(noBranchScope.effectiveNarrowedPaths());
           branchExitOwnershipScopes.push(noBranchScope);
         }
         mergeBranchInvalidations(scope, branchExitOwnershipScopes);
@@ -34642,12 +34650,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           statement.body,
           conditionLocals
         );
-        this.invalidateLoopEntryNarrowingsAssignedBy(
-          loopEntryScope,
-          loopScope,
-          [statement.iterator],
-          conditionLocals
-        );
+        const bodyFlow = statementFlow(statement.body, /* @__PURE__ */ new WeakMap());
+        if (bodyFlow.has("fallthrough") || bodyFlow.has("continue")) {
+          this.invalidateLoopEntryNarrowingsAssignedBy(
+            loopEntryScope,
+            loopScope,
+            [statement.iterator],
+            conditionLocals
+          );
+        }
         const condition = this.toBool(
           this.resolveExpression(statement.condition, loopEntryScope),
           statement.condition.pos
@@ -35514,13 +35525,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (assignedPath) {
       const rootEntry = scope.lookup(pathRoot(assignedPath));
       if (rootEntry) {
-        const receiverFacts = receiverNarrowings(
+        const retainedFacts = unaffectedNarrowings(
           assignedPath,
           rootEntry,
           scope
         );
         scope.invalidate(rootEntry);
-        for (const [path, type] of receiverFacts) {
+        for (const [path, type] of retainedFacts) {
           scope.narrow(path, rootEntry, type);
         }
         if (statement.op === "=" && !isNullable(value.type)) {
@@ -35737,13 +35748,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (assignedPath) {
       const rootEntry = scope.lookup(pathRoot(assignedPath));
       if (rootEntry) {
-        const receiverFacts = receiverNarrowings(
+        const retainedFacts = unaffectedNarrowings(
           assignedPath,
           rootEntry,
           scope
         );
         scope.invalidate(rootEntry);
-        for (const [path, type] of receiverFacts) {
+        for (const [path, type] of retainedFacts) {
           scope.narrow(path, rootEntry, type);
         }
       }
@@ -36358,18 +36369,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       case "coalesce": {
         const left = this.resolveExpression(expression.left, scope);
         const leftOptional = { ...left.type, nullable: true };
+        const nullLeft = isNull(left.type);
         const right = this.resolveExpression(
           expression.right,
           scope,
-          leftOptional
+          nullLeft ? expected : leftOptional
         );
-        if (!isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
+        if (!nullLeft && !isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
           throw new CompileError(
             `\`??\` right operand ${this.describe(right.type)} is not assignable to ${this.describe(leftOptional)}`,
             expression.pos
           );
         }
-        const resultType = {
+        const resultType = nullLeft ? right.type : {
           ...left.type,
           nullable: isNullable(left.type) && isNullable(right.type)
         };
@@ -37070,20 +37082,25 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     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.
+   * A loop body is resolved once but can execute repeatedly. Hide facts about
+   * paths it may replace before resolving the shared iteration; unrelated facts
+   * still hold, and the loop condition can narrow the written paths again.
    */
   invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements, locals = /* @__PURE__ */ new Set()) {
-    for (const rootName of collectAssignedPathRoots(
+    for (const assignedPath of collectAssignedPaths(
       statements,
       /* @__PURE__ */ new Set(),
       locals
     )) {
-      const path = this.narrowingPath(rootName, outerScope);
+      const path = this.narrowingPath(assignedPath, outerScope);
       const outerEntry = path === null ? null : outerScope.lookup(pathRoot(path));
-      if (outerEntry) loopEntryScope.hideInheritedNarrowing(outerEntry);
+      if (outerEntry && path !== null) {
+        const retained = unaffectedNarrowings(path, outerEntry, loopEntryScope);
+        loopEntryScope.hideInheritedNarrowing(outerEntry);
+        for (const [retainedPath, type] of retained) {
+          loopEntryScope.narrow(retainedPath, outerEntry, type);
+        }
+      }
     }
   }
   applyFactsToScope(targetScope, facts, mode = "all") {
@@ -41503,12 +41520,18 @@ function identPathSegments(expression) {
   if (receiver === null) return null;
   return [...receiver, expression.name];
 }
-function receiverNarrowings(path, rootEntry, scope) {
+function unaffectedNarrowings(path, rootEntry, scope) {
   const facts = [];
-  for (let dot = path.indexOf("."); dot !== -1; dot = path.indexOf(".", dot + 1)) {
-    const prefix = path.slice(0, dot);
-    const type = scope.lookupNarrowedType(prefix, rootEntry);
-    if (type !== null) facts.push([prefix, type]);
+  const prefix = `${path}.`;
+  const dot = path.lastIndexOf(".");
+  if (dot === -1) return facts;
+  const member = path.slice(dot);
+  for (const [candidate, narrowed] of scope.effectiveNarrowedPaths()) {
+    if (narrowed.rootEntry !== rootEntry) continue;
+    if (candidate === path || candidate.startsWith(prefix)) continue;
+    if (candidate.endsWith(member) || candidate.includes(`${member}.`))
+      continue;
+    facts.push([candidate, narrowed.type]);
   }
   return facts;
 }
@@ -41832,22 +41855,22 @@ function localsWithBindings(locals, expression, whenTrue) {
     ...facts.flatMap((fact) => fact.bindingName ? [fact.bindingName] : [])
   ]);
 }
-function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(), inheritedLocals = /* @__PURE__ */ new Set(), flowCache = /* @__PURE__ */ new WeakMap()) {
+function collectAssignedPaths(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 && !locals.has(pathRoot(assignedPath))) {
-        roots.add(pathRoot(assignedPath));
+        roots.add(assignedPath);
       }
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.target,
         roots,
         locals,
         flowCache
       );
       if (statement.value)
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           statement.value,
           roots,
           locals,
@@ -41856,7 +41879,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "varDecl") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.init,
         roots,
         locals,
@@ -41870,7 +41893,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       const falseFacts = [];
       const fallthroughFacts = [];
       for (const branch of statement.branches) {
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           branch.cond,
           roots,
           falseLocals,
@@ -41880,7 +41903,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
           ...falseFacts,
           ...factsWhenTrue(branch.cond, canonicalPath)
         ];
-        collectAssignedPathRoots(
+        collectAssignedPaths(
           branch.body,
           roots,
           localsWithBindings(falseLocals, branch.cond, true),
@@ -41892,12 +41915,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
         falseLocals = localsWithBindings(falseLocals, branch.cond, false);
       }
       if (statement.elseBody) {
-        collectAssignedPathRoots(
-          statement.elseBody,
-          roots,
-          falseLocals,
-          flowCache
-        );
+        collectAssignedPaths(statement.elseBody, roots, falseLocals, flowCache);
         if (statementFlow(statement.elseBody, flowCache).has("fallthrough"))
           fallthroughFacts.push(falseFacts);
       } else {
@@ -41909,18 +41927,18 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "try") {
-      collectAssignedPathRoots(statement.body, roots, locals, flowCache);
+      collectAssignedPaths(statement.body, roots, locals, flowCache);
       for (const clause of statement.catches) {
         const catchLocals = /* @__PURE__ */ new Set([...locals, clause.name]);
         if (clause.filter) {
-          collectAssignedPathRootsInExpression(
+          collectAssignedPathsInExpression(
             clause.filter,
             roots,
             catchLocals,
             flowCache
           );
         }
-        collectAssignedPathRoots(
+        collectAssignedPaths(
           clause.body,
           roots,
           clause.filter ? localsWithBindings(catchLocals, clause.filter, true) : catchLocals,
@@ -41930,13 +41948,13 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "while" || statement.kind === "doWhile") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.condition,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         statement.body,
         roots,
         statement.kind === "while" ? localsWithBindings(locals, statement.condition, true) : locals,
@@ -41945,14 +41963,14 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "for") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.initializer.init,
         roots,
         locals,
         flowCache
       );
       const loopLocals = /* @__PURE__ */ new Set([...locals, statement.initializer.name]);
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.condition,
         roots,
         loopLocals,
@@ -41963,22 +41981,17 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
         statement.condition,
         true
       );
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         [statement.iterator],
         roots,
         iterationLocals,
         flowCache
       );
-      collectAssignedPathRoots(
-        statement.body,
-        roots,
-        iterationLocals,
-        flowCache
-      );
+      collectAssignedPaths(statement.body, roots, iterationLocals, flowCache);
       continue;
     }
     if (statement.kind === "forEach") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.collection,
         roots,
         locals,
@@ -41986,11 +41999,11 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       );
       const loopLocals = /* @__PURE__ */ new Set([...locals, statement.name]);
       if (statement.key) loopLocals.add(statement.key.name);
-      collectAssignedPathRoots(statement.body, roots, loopLocals, flowCache);
+      collectAssignedPaths(statement.body, roots, loopLocals, flowCache);
       continue;
     }
     if (statement.kind === "switch") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.selector,
         roots,
         locals,
@@ -41999,7 +42012,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       for (const section of statement.sections) {
         for (const label of section.labels) {
           if (label.kind === "case") {
-            collectAssignedPathRootsInExpression(
+            collectAssignedPathsInExpression(
               label.expression,
               roots,
               locals,
@@ -42007,13 +42020,13 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
             );
           }
         }
-        collectAssignedPathRoots(section.body, roots, locals, flowCache);
+        collectAssignedPaths(section.body, roots, locals, flowCache);
       }
       continue;
     }
     if (statement.kind === "return" || statement.kind === "throw") {
       if (statement.expr)
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           statement.expr,
           roots,
           locals,
@@ -42022,7 +42035,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "exprStmt") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.expr,
         roots,
         locals,
@@ -42032,43 +42045,28 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
   }
   return roots;
 }
-function collectAssignedPathRootsInExpression(expression, roots, locals, flowCache) {
+function collectAssignedPathsInExpression(expression, roots, locals, flowCache) {
   switch (expression.kind) {
     case "litInterp":
       for (const part of expression.parts) {
         if (part.kind === "expr") {
-          collectAssignedPathRootsInExpression(
-            part.expr,
-            roots,
-            locals,
-            flowCache
-          );
+          collectAssignedPathsInExpression(part.expr, roots, locals, flowCache);
         }
       }
       return;
     case "litList":
       for (const element of expression.elements) {
-        collectAssignedPathRootsInExpression(element, roots, locals, flowCache);
+        collectAssignedPathsInExpression(element, roots, locals, flowCache);
       }
       return;
     case "litDict":
       for (const entry of expression.entries) {
-        collectAssignedPathRootsInExpression(
-          entry.key,
-          roots,
-          locals,
-          flowCache
-        );
-        collectAssignedPathRootsInExpression(
-          entry.value,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(entry.key, roots, locals, flowCache);
+        collectAssignedPathsInExpression(entry.value, roots, locals, flowCache);
       }
       return;
     case "member":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.receiver,
         roots,
         locals,
@@ -42076,13 +42074,13 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "index":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.receiver,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.index,
         roots,
         locals,
@@ -42090,32 +42088,22 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "call":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.callee,
         roots,
         locals,
         flowCache
       );
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(
-          argument2,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
       }
       return;
     case "new":
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(
-          argument2,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
       }
       for (const initializer of expression.initializer ?? []) {
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           initializer.value,
           roots,
           locals,
@@ -42126,15 +42114,10 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
     case "annotated":
       for (const annotation2 of expression.annotations) {
         for (const argument2 of annotation2.args) {
-          collectAssignedPathRootsInExpression(
-            argument2,
-            roots,
-            locals,
-            flowCache
-          );
+          collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
         }
       }
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.expression,
         roots,
         locals,
@@ -42143,13 +42126,13 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "binary":
     case "coalesce":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.left,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.right,
         roots,
         locals,
@@ -42157,19 +42140,19 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "conditional":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.condition,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.whenTrue,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.whenFalse,
         roots,
         locals,
@@ -42178,7 +42161,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "unary":
     case "force":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -42186,7 +42169,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "is":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -42194,7 +42177,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "lambda":
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         expression.body,
         roots,
         /* @__PURE__ */ new Set([
@@ -54658,7 +54641,7 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.72.2",
+  cliVersion: "0.72.4",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.72.2",
+  "version": "0.72.4",
   "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.72.2 -->
+<!-- reviewed-through-cli: 0.72.4 -->
 
 # Neo Compose CLI
 

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

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

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

@@ -178,7 +178,13 @@ or narrowing guard before the next access.
 Inside an instance body, `Member` and `this.Member` share null and type-check
 narrowing. A local or parameter named `Member` shadows the implicit member;
 `this.Member` still names the instance field. Reassigning a narrowed path to a
-nullable value clears its non-null fact.
+nullable value clears its non-null fact and facts about its descendants. Writes to
+unrelated members preserve existing guards, including inside loops. Earlier
+conditions being false also narrow receivers in later `else if` conditions.
+
+A nullable value coalesced with a non-null fallback produces a non-null result,
+including in constructor arguments: `new Sprite(item.Sprite ?? SpriteInfo.Empty)`.
+A nullable fallback keeps the result nullable when the left operand can be null.
 
 Treat lookup-return values with the same nullable narrowing rules.
 

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

@@ -57,7 +57,10 @@ keys as quoted IDs when their option has been deleted.
 
 ## Identity rules
 
-Preserve every existing ID through rename, reorder, and file moves. A copy
+Preserve every existing ID through rename, reorder, and file moves. Renaming a
+schema member while keeping its ID preserves its owned value graph. Update
+initializer keys to the new name and retain existing child IDs, including when
+editing those children in the same change. A copy
 must get a new ID. A stored nested class value may keep its UUID-v4 when moved
 to an empty, compatible class field on another existing parent. Remove its
 old owning declaration in the same push. Both fields must declare the same