@neocompose/cli 0.84.2 → 0.84.3

package/dist/test-worker.mjs

@@ -21257,6 +21257,7 @@ function createdSessionValuesSince(ctx, checkpoint) {
   return created;
 }
 function exportInitializerCollections(created, writes, ctx) {
+  const inPlace = (value) => value instanceof RuntimeSet ? exportRuntimeSetValue(value, ctx) : value;
   const assignedValues = /* @__PURE__ */ new Set();
   const mutatedIds = /* @__PURE__ */ new Set();
   for (const write of writes) {
@@ -21264,83 +21265,134 @@ function exportInitializerCollections(created, writes, ctx) {
     if (destination !== void 0 && "containerValueId" in destination)
       mutatedIds.add(destination.containerValueId);
     if (write.kind === "assign" && write.valueId === void 0 && typeof write.value === "object" && write.value !== null) {
-      assignedValues.add(write.value);
+      assignedValues.add(inPlace(write.value));
     }
   }
   const candidates = /* @__PURE__ */ new Set();
+  const inlineFieldsByRowId = /* @__PURE__ */ new Map();
   for (const row of created) {
-    if (assignedValues.has(row.value) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
+    const inlineFields = inlineCollectionFields(row, ctx);
+    if (inlineFields !== null) inlineFieldsByRowId.set(row.id, inlineFields);
+    if (inlineFields !== null || assignedValues.has(inPlace(row.value)) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
       candidates.add(row.id);
     }
   }
   if (candidates.size === 0) return created;
   invalidateEvaluatorIndexes(ctx, null);
   const extra = [];
-  const exported = created.map((row) => {
-    if (!candidates.has(row.id)) return row;
-    const member = memberForValueRow(row, ctx);
-    if (member === null) return row;
-    if (!isMemberWithEntries(member)) return row;
-    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
-      return { ...row, value: [] };
-    }
-    if (!assignedValues.has(row.value) && !mutatedIds.has(row.id)) return row;
-    const values = [];
+  const encode = (member, value, genericEnv, collectionOwnerId) => {
+    const rows = [];
     const declarations = /* @__PURE__ */ new Map();
-    const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
-    overlayConcreteGenericEntries(
-      genericEnv,
-      envFromStamp(row.genericBindings)
-    );
-    const materialized = materializeConstructorArgumentValue({
+    const root = materializeConstructorArgumentValue({
       member,
-      value: row.value,
+      value,
       genericEnv,
       ctx,
-      createdValues: values,
+      createdValues: rows,
       createdById: /* @__PURE__ */ new Map(),
       storageKeyDeclarations: declarations,
-      collectionEntriesAreReferences: assignedValues.has(row.value) ? false : void 0,
-      collectionOwnerId: row.id
+      collectionEntriesAreReferences: assignedValues.has(value) ? false : void 0,
+      collectionOwnerId
     });
-    const encoded = { ...row, value: materialized.value };
-    const children = values.filter((value) => value !== materialized);
-    declarations.delete(materialized.id);
-    const groupId = constructorGroupForRow(row.id, ctx);
-    retargetConstructorGroupDependencies(
-      materialized.id,
-      groupId ?? row.id,
-      ctx
-    );
+    const children = rows.filter((row) => row !== root);
+    return { root, children, declarations };
+  };
+  const adopt = (owner, rootId, rows, declarations) => {
+    const groupId = constructorGroupForRow(owner.id, ctx);
+    retargetConstructorGroupDependencies(rootId, groupId ?? owner.id, ctx);
     if (groupId !== null) {
       const state = ctx.__executionState;
       const group = state?.constructorGroups.get(groupId);
-      for (const child of children) {
-        retargetConstructorGroupDependencies(child.id, groupId, ctx);
-        group?.add(child.id);
-        state?.constructorGroupByRowId.set(child.id, groupId);
+      for (const row of rows) {
+        retargetConstructorGroupDependencies(row.id, groupId, ctx);
+        group?.add(row.id);
+        state?.constructorGroupByRowId.set(row.id, groupId);
       }
     }
-    stampCreatedValuesMapKey(children, row.mapKey);
+    stampCreatedValuesMapKey(rows, owner.mapKey);
     applyDeclaredStorageKeyOverrides({
-      createdValues: [encoded, ...children],
+      createdValues: [owner, ...rows],
       declarationByValueId: declarations
     });
-    for (const child of children) {
-      if (!isLiteralValueContent(child)) {
+    for (const row of rows) {
+      if (!isLiteralValueContent(row)) {
         throw new NSGetterRuntimeError(
           "Initializer collection produced an unevaluated row."
         );
       }
-      extra.push(child);
+      extra.push(row);
     }
     for (const [id, declaration] of declarations) {
       ctx.__createdStorageKeyDeclarations?.set(id, declaration);
     }
+  };
+  const exported = created.map((row) => {
+    if (!candidates.has(row.id)) return row;
+    const inlineFields = inlineFieldsByRowId.get(row.id);
+    if (inlineFields !== void 0) {
+      const record4 = { ...inlineFields.record };
+      const encoded2 = { ...row, value: record4 };
+      for (const [key, member2] of inlineFields.members) {
+        const { root: root2, children: children2, declarations: declarations2 } = encode(
+          member2,
+          inPlace(record4[key]),
+          inlineFields.genericEnv
+        );
+        record4[key] = root2.id;
+        adopt(encoded2, root2.id, [root2, ...children2], declarations2);
+      }
+      return encoded2;
+    }
+    const member = memberForValueRow(row, ctx);
+    if (member === null) return row;
+    if (!isMemberWithEntries(member)) return row;
+    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
+      return { ...row, value: [] };
+    }
+    const value = inPlace(row.value);
+    if (!assignedValues.has(value) && !mutatedIds.has(row.id)) return row;
+    const { root, children, declarations } = encode(
+      member,
+      value,
+      rowGenericEnv(row, ctx),
+      row.id
+    );
+    const encoded = { ...row, value: root.value };
+    declarations.delete(root.id);
+    adopt(encoded, root.id, children, declarations);
     return encoded;
   });
   return [...exported, ...extra];
 }
+function inlineCollectionFields(row, ctx) {
+  if (typeof row.classId !== "string") return null;
+  if (!isPlainRecord(row.value)) return null;
+  let fields = null;
+  for (const key in row.value) {
+    const value = row.value[key];
+    if (typeof value !== "object" || value === null) continue;
+    const rawMember = memberForCustomSchemaValue(row.classId, key, ctx);
+    if (rawMember === null) continue;
+    fields ??= {
+      record: row.value,
+      members: /* @__PURE__ */ new Map(),
+      genericEnv: rowGenericEnv(row, ctx)
+    };
+    const member = substituteMember(
+      rawMember,
+      fields.genericEnv,
+      ctx.vm.members,
+      cachedResolvedMember(rawMember, ctx)
+    );
+    if (isMemberWithEntries(member)) fields.members.set(key, member);
+  }
+  return fields === null || fields.members.size === 0 ? null : fields;
+}
+function rowGenericEnv(row, ctx) {
+  const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
+  overlayConcreteGenericEntries(genericEnv, envFromStamp(row.genericBindings));
+  return genericEnv;
+}
 function prepareSessionValueExport(ctx, checkpoint, writes) {
   const created = createdSessionValuesSince(ctx, checkpoint);
   if (created.length === 0) return;
@@ -32875,6 +32927,7 @@ function clonedConstructorProvenance(source) {
 }
 function cloneConstructorLiteralValue(value) {
   if (typeof value !== "object" || value === null) return value;
+  if (value instanceof NSSlotReference) return value.targetId;
   if (Array.isArray(value)) {
     return value.map((entry) => cloneConstructorLiteralValue(entry));
   }
@@ -37136,7 +37189,7 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
           const typeInfo = parameterTypes.get(parameterId);
           return [
             parameterId,
-            typeInfo !== void 0 && isAggregateTypeInfo(typeInfo) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
+            typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
           ];
         }
       )
@@ -37172,6 +37225,41 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
       ids.push(edge.targetValueId);
     return ids;
   }
+  /** The targets a row's Reference creation data names (P112 §1.1). */
+  referenceArgumentIds(row) {
+    if (!isLiteralValueContent(row)) return [];
+    const args = row.constructorArgs;
+    if (args === void 0 || args === null) return [];
+    const ids = [];
+    for (const parameterId of this.referenceParameterIds(row)) {
+      const argument2 = args[parameterId];
+      if (typeof argument2 === "string") ids.push(argument2);
+    }
+    return ids;
+  }
+  /** Creation data with each Reference argument's target remapped (P112 §1.1). */
+  remapReferenceArguments(row, remap, contextualMember) {
+    const args = row.constructorArgs;
+    if (args === void 0 || args === null) return args;
+    let remapped;
+    for (const parameterId of this.referenceParameterIds(
+      row,
+      contextualMember
+    )) {
+      const argument2 = args[parameterId];
+      if (typeof argument2 !== "string") continue;
+      const target = remap(argument2);
+      if (target !== argument2) (remapped ??= { ...args })[parameterId] = target;
+    }
+    return remapped ?? args;
+  }
+  *referenceParameterIds(row, contextualMember) {
+    for (const [parameterId, typeInfo] of this.constructorParameterTypes(
+      row,
+      contextualMember
+    ))
+      if (typeInfo.type === 29 /* Reference */) yield parameterId;
+  }
   slotEntries(row) {
     const value = row.value;
     switch (this.referenceSlots(row.id, void 0, value)) {
@@ -38193,7 +38281,11 @@ function resolveVirtualInstanceGraph(args) {
         }
       }
     }
-    const virtualRow = rewriteExpandedRow(indexed, expansion);
+    const virtualRow = rewriteExpandedRow(
+      indexed,
+      expansion,
+      materializedGraph
+    );
     const location = {
       id: effectiveId2,
       instanceRootId: args.instanceRoot.id,
@@ -39447,7 +39539,7 @@ function indexExpansion(args) {
     membersById
   };
 }
-function rewriteExpandedRow(node, expansion) {
+function rewriteExpandedRow(node, expansion, graph) {
   const rewrite = (id) => expansion.nodesByExpandedId.get(id)?.virtualId ?? id;
   const row = cloneRow(node.expandedRow);
   row.id = node.virtualId;
@@ -39469,6 +39561,12 @@ function rewriteExpandedRow(node, expansion) {
   if (node.member.kind === 9 /* Lookup */) {
     row.value = remapLookupSelection(row.value, rewrite);
   }
+  if (isLiteralValueContent(row) && row.constructorArgs !== void 0)
+    row.constructorArgs = graph.remapReferenceArguments(
+      row,
+      rewrite,
+      node.member
+    );
   if (typeof row.containerId === "string") {
     row.containerId = rewrite(row.containerId);
   }
@@ -64110,13 +64208,29 @@ function memberSavedForStorage(ctx, memberId, contextSaved, declarationClassId)
     if (isWritableConstraint(classStorage)) return true;
     if (classStorage === 1 /* Immutable */) return false;
   }
-  const effective = ctx.storageResolver.effectiveStorages(memberId);
+  let effective = ctx.storageResolver.effectiveStorages(memberId);
+  const visited = /* @__PURE__ */ new Set([memberId]);
+  let currentId = memberId;
+  let baseId = member?.extendsMemberId;
+  while (effective.size === 0 && baseId !== void 0 && !visited.has(baseId)) {
+    if (!isResolvedAbstract(ctx, currentId) && !isResolvedAbstract(ctx, baseId))
+      break;
+    visited.add(baseId);
+    effective = ctx.storageResolver.effectiveStorages(baseId);
+    currentId = baseId;
+    baseId = ctx.exportData.members[baseId]?.extendsMemberId;
+  }
   const hasWritable = effective.has(2 /* Save */) || effective.has(3 /* Session */);
   const hasStatic = effective.has(1 /* Immutable */);
   if (hasWritable && !hasStatic) return true;
   if (hasStatic && !hasWritable) return false;
   return contextSaved;
 }
+function isResolvedAbstract(ctx, memberId) {
+  return isAbstractMember(
+    resolveMemberById(ctx, memberId, `members.${memberId}`)
+  );
+}
 function classAllowedStorage(ctx, classId) {
   return ctx.storageResolver.allowedStorage(classId);
 }
@@ -64998,7 +65112,7 @@ function typeInfoConstructedSuffix(ctx, typeInfo, saved, genericEnv, genericBind
     const argType = csharpTypeInfoValueType(
       ctx,
       argInfo,
-      saved,
+      true,
       genericEnv,
       genericBindingSaved
     );

package/package.json

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

package/skills/neocompose-cli/SKILL.md

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

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

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

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

@@ -254,6 +254,17 @@ and declarations created in the same push. Preparation materializes the target
 collection and its required ancestor rows together, preserving the virtual
 identities. No preliminary push or manual value ID is needed.
 
+An object Root.neo writes is init-built when its class has an `init` block. A
+declaration binding may name a member inside it, and the push stores that
+member's row so the binding has a target. A reference an `init` block or
+constructor captures, such as `new Rule(Reference(this.Weather))`, stores its
+target's ID and keeps the target's row. Status refuses two forms, because their
+target has no row to check until the push stores it: a value row's reference to
+a member of an init-built object (bind it from a declaration instead), and a
+binding to a class or list an `init` block builds. A project an older CLI pushed
+with such a captured reference stored it without its target; push once to
+repair it.
+
 ## Defaults and localization
 
 A class member whose default constructs its declared type emits a contextual