@neocompose/cli 0.36.2 → 0.36.4

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [0.36.4] - 2026-08-19
+
+### Fixed
+
+- Keep computed static/root binding value identities derived from their member
+  ids, so post-push source rewriting never inserts an `@id` inside the
+  initializer expression.
+- Validate assigned-id source rewriting during `neo push --dry-run`, and keep
+  materialized scalar bindings stable so a successful push is followed by a
+  clean `neo status` without changing the authored initializer expression.
+
+## [0.36.3] - 2026-08-19
+
+### Fixed
+
+- Preserve nullable List and Dictionary entry declarations in persisted
+  compiler contexts, and keep abstract stored collection fields writable
+  through the concrete subclass storage that implements them. Indexed
+  `is`-pattern reads and writes such as `Stacks[index] = null` now agree in
+  source analysis, IntelliSense, `neo script check --all`, and push replay.
+- Run `neo script check --all` against one locally reconstructed prospective
+  project document instead of fetching a stale server document through a
+  separate path. New records, managed files, dialogues, and stored bodies are
+  validated with the same source transaction visible to local member bodies.
+- Compile canonical `Reference<NeoImage>(id: ...).Slice(...)` and
+  `Reference<NeoAudioClip>(id: ...)` file fallbacks when a pulled file has no
+  registry symbol, and accept `List.Repeat<T>(value, count)` when an explicit
+  entry type is needed for values such as `null`.
+- Include same-transaction texture and audio import-template changes in the
+  prospective document before validating managed-file defaults.
+
 ## [0.36.2] - 2026-08-19
 
 ### Fixed

package/dist/neo.mjs

@@ -1278,6 +1278,12 @@ function neoScriptRegistryEntryType(typeName) {
   }
   return REGISTRY_ENTRY_TYPES[typeName] ?? null;
 }
+function neoScriptRegistryReferenceType(entryTypeName) {
+  for (const definition2 of Object.values(REGISTRY_ENTRY_TYPES)) {
+    if (definition2.entryType === entryTypeName) return definition2.refType;
+  }
+  return null;
+}
 function parameter(name, type) {
   return { name, type };
 }
@@ -11398,6 +11404,19 @@ var init_strict_resolver = __esm({
                   expression.pos
                 );
               }
+              if (isPrimitive(referencedType, "ImageRef") || isPrimitive(referencedType, "AudioClipRef")) {
+                if (hasProvenanceArgument) {
+                  throw new CompileError(
+                    `Reference<${referenceTypeArgument.kind === "named" ? referenceTypeArgument.name : "file"}> does not support withProvenance because a project file reference is a file id, not a value-row reference.`,
+                    expression.pos
+                  );
+                }
+                return literal(
+                  referencedType,
+                  expression.args[0].value,
+                  this.project
+                );
+              }
               return {
                 pointer: {
                   type: "reference" /* Reference */,
@@ -11407,6 +11426,37 @@ var init_strict_resolver = __esm({
                 type: referencedType
               };
             }
+            if (expression.typeArguments && expression.callee.kind === "member" && expression.callee.receiver.kind === "ident" && expression.callee.receiver.name === NEOSCRIPT_LIST_TYPE_NAME) {
+              if (expression.callee.name !== NEOSCRIPT_LIST_REPEAT_NAME) {
+                throw new CompileError(
+                  `'${NEOSCRIPT_LIST_TYPE_NAME}' has no generic static member '${expression.callee.name}'.`,
+                  expression.pos
+                );
+              }
+              if (expression.typeArguments.length !== 1) {
+                throw new CompileError(
+                  `${NEOSCRIPT_LIST_TYPE_NAME}.${NEOSCRIPT_LIST_REPEAT_NAME}<T> requires exactly one entry type argument.`,
+                  expression.pos
+                );
+              }
+              const entryTypeArgument = expression.typeArguments[0];
+              if (entryTypeArgument === void 0) {
+                throw new CompileError(
+                  `${NEOSCRIPT_LIST_TYPE_NAME}.${NEOSCRIPT_LIST_REPEAT_NAME}<T> requires exactly one entry type argument.`,
+                  expression.pos
+                );
+              }
+              return this.resolveListStaticCall(
+                expression.callee.name,
+                expression.args,
+                scope,
+                {
+                  kind: "list",
+                  elementType: this.resolveType(entryTypeArgument)
+                },
+                expression.pos
+              );
+            }
             if (expression.typeArguments) {
               throw new CompileError(
                 "Generic intrinsic calls require a declaration-aware project source context.",
@@ -15209,11 +15259,17 @@ var init_strict_resolver = __esm({
        */
       assertActionControlAccessible(action, operation, pos) {
         const symbol = action.symbol;
-        const owner = symbol === void 0 ? void 0 : symbol.inheritedFrom ? this.project.typeById.get(symbol.inheritedFrom.typeId) : [...this.project.typeById.values()].find(
-          (type) => type.members.some(
-            (candidate) => candidate.id === symbol.id && candidate.inheritedFrom === void 0
-          )
-        );
+        let owner = symbol?.inheritedFrom ? this.project.typeById.get(symbol.inheritedFrom.typeId) : void 0;
+        if (symbol !== void 0 && symbol.inheritedFrom === void 0) {
+          for (const type of this.project.typeById.values()) {
+            if (type.members.some(
+              (candidate) => candidate.id === symbol.id && candidate.inheritedFrom === void 0
+            )) {
+              owner = type;
+              break;
+            }
+          }
+        }
         if (symbol !== void 0 && owner !== void 0 && memberAccessFailure({
           project: this.project,
           context: this.context,
@@ -15535,6 +15591,11 @@ var init_strict_resolver = __esm({
               resolved = { kind: "primitive", name: builtin };
               break;
             }
+            const registryReference = neoScriptRegistryReferenceType(type.name);
+            if (registryReference) {
+              resolved = registryReference;
+              break;
+            }
             const named = this.project.typeByName.get(type.name);
             if (!named)
               throw new CompileError(`Unknown type '${type.name}'`, type.pos);
@@ -32603,10 +32664,8 @@ function attachConstructorSignature(type, environment) {
     type.id,
     environment
   );
-  if ([...genericEnvironment.values()].some(
-    (binding) => binding.kind === "unbound"
-  )) {
-    return type;
+  for (const binding of genericEnvironment.values()) {
+    if (binding.kind === "unbound") return type;
   }
   const constructorSignature2 = buildNeoScriptConstructorSignature(
     type.id,
@@ -32939,7 +32998,7 @@ function memberSymbol(member, schemaKey, environment, field) {
       writable: false
     };
   }
-  const writable = isReadOnly ? false : kind === "computed" ? computedHasSetter(member, field) : modifier !== "abstract" && member.locked !== true;
+  const writable = isReadOnly ? false : kind === "computed" ? computedHasSetter(member, field) : member.locked !== true;
   const storage = typeof member.storage === "string" ? member.storage : void 0;
   const writability = isReadOnly ? "readOnly" : kind === "computed" ? writable ? "setter" : "readOnly" : !writable ? "readOnly" : storage === "immutable" || storage === "save" || storage === "session" ? storage : isStatic && ownerClassId ? staticDefaultWritability(ownerClassId, environment) : void 0;
   const lookupCollectionMemberId = kind === "lookup" ? string2(member.collectionMemberId, `${field}.collectionMemberId`) : null;
@@ -33475,9 +33534,12 @@ function memberType(member, environment, visiting, field) {
     };
   }
   if (kind === "variant") {
-    const variantClass = [...environment.classes.values()].find(
-      (candidate) => candidate.name === NEO_VARIANT_TYPE_NAME
-    );
+    let variantClass;
+    for (const candidate of environment.classes.values()) {
+      if (candidate.name !== NEO_VARIANT_TYPE_NAME) continue;
+      variantClass = candidate;
+      break;
+    }
     if (variantClass === void 0) return { ...unknownType(), nullable };
     return {
       kind: "named",
@@ -61766,7 +61828,8 @@ function interfaceToLanguageType(neoInterface, context) {
     closure = [neoInterface];
   }
   const members = /* @__PURE__ */ new Map();
-  for (const source of [...closure].reverse()) {
+  for (let index = closure.length - 1; index >= 0; index -= 1) {
+    const source = closure[index];
     for (const key of getInterfaceMemberKeyOrder(source)) {
       const member = source.members[key];
       if (!member) continue;
@@ -62013,13 +62076,11 @@ function memberRuntimeType(record3, context, seen = /* @__PURE__ */ new Set(), g
       const projectedEntry = entry ? substituteForGenericEnvironment(entry, genericEnvironment, context) : null;
       return {
         kind: "list",
-        elementType: projectedEntry ? requiredType(
-          memberRuntimeType(
-            projectedEntry,
-            context,
-            nextSeen,
-            genericEnvironment
-          )
+        elementType: projectedEntry ? memberRuntimeType(
+          projectedEntry,
+          context,
+          nextSeen,
+          genericEnvironment
         ) : UNKNOWN_TYPE2,
         listMemberId: record3.id,
         nullable: !required2
@@ -62032,13 +62093,11 @@ function memberRuntimeType(record3, context, seen = /* @__PURE__ */ new Set(), g
       return {
         kind: "dictionary",
         keyType: member.keyKind === "enum" && member.keyEnumId ? namedType(member.keyEnumId, true) : primitive2("string", true),
-        valueType: projectedEntry ? requiredType(
-          memberRuntimeType(
-            projectedEntry,
-            context,
-            nextSeen,
-            genericEnvironment
-          )
+        valueType: projectedEntry ? memberRuntimeType(
+          projectedEntry,
+          context,
+          nextSeen,
+          genericEnvironment
         ) : UNKNOWN_TYPE2,
         nullable: !required2
       };
@@ -63037,7 +63096,10 @@ function initializerReferencesLexicalThis(source) {
 }
 function initializerReferencesAnyIdentifier(source, names) {
   const identifiers = initializerReferencedIdentifiers(source);
-  return [...names].some((name) => identifiers.has(name));
+  for (const name of names) {
+    if (identifiers.has(name)) return true;
+  }
+  return false;
 }
 function compileNSPropertyBodies(args) {
   if (args.member.kind !== 10 /* NSProperty */) return;
@@ -63639,7 +63701,7 @@ function declaredConstructorsOfClass(constructors, schemaClass2) {
   });
 }
 function argumentNameSetKey2(names) {
-  return [...names].map((name) => name.toLowerCase()).sort().join(", ");
+  return names.map((name) => name.toLowerCase()).sort().join(", ");
 }
 function describeConstructorOverloads(constructors) {
   return constructors.map(
@@ -63739,7 +63801,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
     return {
       type: resolved.kind,
       required: resolved.required,
-      entryTypeInfo: { ...entryTypeInfo, required: true },
+      entryTypeInfo,
       ...isMemberDictionaryBase(resolved) && resolved.keyEnumId ? { keyEnumId: resolved.keyEnumId } : {}
     };
   }
@@ -92000,7 +92062,12 @@ function materializeAuthoredListItems(args) {
     args.member.entryMemberId
   );
   const unordered = listKindOf(args.member) === "unordered";
-  const ids = unordered ? [...args.authoredRows.values()].filter((row) => row.containerId === args.row.id).map((row) => row.id) : args.row.value;
+  const ids = unordered ? [] : args.row.value;
+  if (unordered) {
+    for (const row of args.authoredRows.values()) {
+      if (row.containerId === args.row.id) ids.push(row.id);
+    }
+  }
   const materializedIds = [];
   for (const childId of ids) {
     if (typeof childId !== "string") {
@@ -92259,6 +92326,12 @@ function initBackedValueRow(value) {
   if (!isMemberValue(value)) return null;
   return isInitValueContent(value) ? value : null;
 }
+function valueIdsFromRows(explicitRows, sweepRows) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const row of explicitRows) ids.add(row.id);
+  for (const row of sweepRows) ids.add(row.id);
+  return ids;
+}
 function prepareServerOwnedValueInitializerBodies(args) {
   const explicitRows = /* @__PURE__ */ new Map();
   for (let index = 0; index < args.prepared.length; index += 1) {
@@ -92280,10 +92353,7 @@ function prepareServerOwnedValueInitializerBodies(args) {
     args.postDocument,
     args.prepared
   );
-  const targetIds = /* @__PURE__ */ new Set([
-    ...[...explicitRows.values()].map((row) => row.id),
-    ...sweepRows.map((row) => row.id)
-  ]);
+  const targetIds = valueIdsFromRows(explicitRows.values(), sweepRows);
   const valuesById = new Map(
     committedDocument.values.map((value) => [value.id, value])
   );
@@ -92410,10 +92480,7 @@ function prepareServerOwnedDelegateValueBodies(args) {
     args.postDocument,
     args.prepared
   );
-  const targetIds = /* @__PURE__ */ new Set([
-    ...[...explicitRows.values()].map((row) => row.id),
-    ...sweepRows.map((row) => row.id)
-  ]);
+  const targetIds = valueIdsFromRows(explicitRows.values(), sweepRows);
   const rootOwnerByValueId = /* @__PURE__ */ new Map();
   const delegateScope = withVariantOwnershipRoots(
     committedDocument,
@@ -92964,6 +93031,20 @@ function applyProjectVersionWriteChanges(document, changes) {
       changes,
       "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: applyArrayChanges(
+      document.textureTemplates ?? [],
+      changes,
+      "unity-texture-template"
+    ),
+    audioClipTemplates: applyArrayChanges(
+      document.audioClipTemplates ?? [],
+      changes,
+      "unity-audio-clip-template"
+    ),
     internalRecordRelations: applyArrayChanges(
       document.internalRecordRelations ?? [],
       changes,
@@ -94884,7 +94965,7 @@ function listVirtualProjectSourceFilesV4(files) {
     const kind = neoProjectSourceKind(file.path);
     return kind !== null && isNeoProjectProductionSourceKind(kind) && !neoProjectPathHasIgnoredDirectory(file.path);
   });
-  const sorted = [...selected].sort(
+  const sorted = selected.sort(
     (left, right) => compareWorkspacePaths(left.path, right.path)
   );
   for (let index = 1; index < sorted.length; index += 1) {
@@ -95525,14 +95606,24 @@ function computeWorkspaceStatus(workspace, options) {
     (binary) => binary.action !== "unchanged" && binary.action !== "converged"
   );
   reportPhase("binary-inspection");
-  const invalidatedFileIds = /* @__PURE__ */ new Set([
-    ...binaryFiles.filter(
-      (binary) => binary.action === "create" || binary.action === "upload"
-    ).map((binary) => binary.fileId),
-    ...options.trustedPendingProjectFiles?.keys() ?? []
-  ]);
+  const invalidatedFileIds = /* @__PURE__ */ new Set();
+  for (const binary of binaryFiles) {
+    if (binary.action === "create" || binary.action === "upload") {
+      invalidatedFileIds.add(binary.fileId);
+    }
+  }
+  for (const fileId of options.trustedPendingProjectFiles?.keys() ?? []) {
+    invalidatedFileIds.add(fileId);
+  }
+  if (options.skipProjectBinaryInspection) {
+    for (const record3 of reconstructed3.values()) {
+      if (record3.recordKind === "project-file" && record3.fullData.status !== "uploaded") {
+        invalidatedFileIds.add(record3.recordId);
+      }
+    }
+  }
   for (const message of validateFinalizedFileAssignmentsV4(
-    [...reconstructed3.values()].map((record3) => ({
+    Array.from(reconstructed3.values(), (record3) => ({
       recordKind: record3.recordKind,
       data: record3.fullData
     })),
@@ -95585,10 +95676,13 @@ function computeWorkspaceStatus(workspace, options) {
         intent: createNeoCliPushIntent(change),
         expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
       })),
-      authoredValueSeeds: [...authoredValueSeeds].map(([memberId, seed]) => ({
-        memberId,
-        ...seed
-      }))
+      authoredValueSeeds: Array.from(
+        authoredValueSeeds,
+        ([memberId, seed]) => ({
+          memberId,
+          ...seed
+        })
+      )
     });
   } catch (error) {
     parseErrors.push(
@@ -95911,12 +96005,23 @@ function prospectiveAnimationRecords(base, reconstructed3, changes, seeds) {
     const key = recordStateKey(change.recordKind, change.recordId);
     if (change.kind === "delete") prospective.delete(key);
   }
-  const projectRecord = [...prospective.values()].find(
-    (record3) => record3.recordKind === "project"
-  ) ?? [...reconstructed3.values()].filter((record3) => record3.recordKind === "project").map((record3) => ({
-    recordKind: record3.recordKind,
-    data: record3.fullData
-  }))[0];
+  let projectRecord;
+  for (const record3 of prospective.values()) {
+    if (record3.recordKind === "project") {
+      projectRecord = record3;
+      break;
+    }
+  }
+  if (projectRecord === void 0) {
+    for (const record3 of reconstructed3.values()) {
+      if (record3.recordKind !== "project") continue;
+      projectRecord = {
+        recordKind: record3.recordKind,
+        data: record3.fullData
+      };
+      break;
+    }
+  }
   const projectId = projectRecord?.data.id;
   const seedEnvelope = typeof projectId === "string" ? { projectId, createdAt: 0, updatedAt: 0 } : {};
   for (const [key, record3] of reconstructed3) {
@@ -97317,43 +97422,47 @@ function compilePulledMemberInitializerBodyV4(document, memberId, compilationPro
 }
 function readPulledProjectDocumentV4(records2) {
   const raw = structuredClone(
-    pulledProjectDocumentRaw(replayWorkspace(records2))
-  );
-  return readProjectDocument(
-    completeProspectiveMemberCreateEnvelopes(
-      completeProspectiveLocalizedTexts(raw)
-    ),
-    {
-      constructors: "authored-or-compiled",
-      identities: "prospective",
-      members: "authored-or-compiled"
-    }
+    pulledProjectDocumentRaw(
+      replayWorkspace(completeProspectiveRecordCreateEnvelopes(records2))
+    )
   );
+  return readProjectDocument(completeProspectiveLocalizedTexts(raw), {
+    constructors: "authored-or-compiled",
+    identities: "prospective",
+    members: "authored-or-compiled"
+  });
 }
-function completeProspectiveMemberCreateEnvelopes(raw) {
-  const members = raw.members;
-  if (!Array.isArray(members)) return raw;
-  if (!members.some(isPendingMemberWithoutCreateEnvelope)) return raw;
-  const project = raw.project;
-  if (!isObjectRecord2(project) || typeof project.id !== "string") {
+function completeProspectiveRecordCreateEnvelopes(records2) {
+  let project;
+  for (const record3 of records2.values()) {
+    if (!record3.deleted && record3.recordKind === "project" && isObjectRecord2(record3.data)) {
+      project = record3;
+      break;
+    }
+  }
+  const projectId = isObjectRecord2(project?.data) ? project.data.id : null;
+  if (typeof projectId !== "string") {
     throw new Error(
-      "Pending source-authored members need the server create envelope, but the project record has no id."
+      "Prospective source-authored records need the server create envelope, but the project record has no id."
     );
   }
-  return {
-    ...raw,
-    members: members.map(
-      (member) => isPendingMemberWithoutCreateEnvelope(member) ? {
-        projectId: project.id,
+  const completed = /* @__PURE__ */ new Map();
+  for (const [key, record3] of records2) {
+    if (record3.deleted || record3.recordKind === "project" || !isObjectRecord2(record3.data) || typeof record3.data.id !== "string" || typeof record3.data.projectId === "string" && typeof record3.data.createdAt === "number" && typeof record3.data.updatedAt === "number") {
+      completed.set(key, record3);
+      continue;
+    }
+    completed.set(key, {
+      ...record3,
+      data: {
+        projectId,
         createdAt: 0,
         updatedAt: 0,
-        ...member
-      } : member
-    )
-  };
-}
-function isPendingMemberWithoutCreateEnvelope(value) {
-  return isObjectRecord2(value) && typeof value.id === "string" && value.id.startsWith("__pending__:") && (typeof value.projectId !== "string" || typeof value.createdAt !== "number" || typeof value.updatedAt !== "number");
+        ...record3.data
+      }
+    });
+  }
+  return completed;
 }
 function completeProspectiveLocalizedTexts(raw) {
   const localizedTexts = raw.localizedTexts;
@@ -99545,7 +99654,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         `Value ${path} in ${source.label} writes @id(${JSON.stringify(unattachedId)}) on part of a computed expression rather than on the row. Parenthesize the expression so the annotation names the whole row.`
       );
     }
-    if (annotated.id === null && isPendingId(valueId) && !context.pendingValueIdentitySites.has(valueId)) {
+    if (annotated.id === null && isPendingId(valueId) && pendingMemberValueMemberId(valueId) === null && !context.pendingValueIdentitySites.has(valueId)) {
       context.pendingValueIdentitySites.set(valueId, {
         id: valueId,
         uri: source.source.uri,
@@ -100149,6 +100258,16 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
     }
     indexInitAuthoredRowIds(context, code, source.label);
     const storedConstructorArgs = isObjectRecord2(base.constructorArgs) ? base.constructorArgs : null;
+    if (resolvedMember.kind !== "class" && isLiteralValueContent(base)) {
+      addReconstructed(
+        context,
+        "value",
+        expectedValueId,
+        valueFileFields(base),
+        source.source
+      );
+      return expectedValueId;
+    }
     const materializedClass = resolvedMember.kind === "class" && isObjectRecord2(base.value);
     const effectiveClassId = resolvedMember.kind === "class" ? stringOrNull(base.classId) ?? resolvedMember.classId : null;
     const materializedPlainClass = materializedClass && effectiveClassId !== null && context.classes.get(effectiveClassId)?.requiredConstructorId === void 0;
@@ -109225,7 +109344,7 @@ function qualifiedMemberLabel(thisClass, member) {
   if (typeof thisClass.name !== "string") return `'${memberName}'`;
   return `'${thisClass.name}.${memberName}'`;
 }
-function analyzeWorkspaceProjectManifestV4(workspace) {
+function analyzeWorkspaceProjectV4(workspace) {
   const status = computeWorkspaceStatus2(workspace, {
     skipProjectBinaryInspection: true
   });
@@ -109250,13 +109369,35 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       data: record3.fullData
     });
   }
-  return documentsToProjectSchemaManifest(documents);
+  const records2 = /* @__PURE__ */ new Map();
+  for (const record3 of status.reconstructed.values()) {
+    records2.set(`${record3.recordKind}:${record3.recordId}`, {
+      recordKind: record3.recordKind,
+      recordId: record3.recordId,
+      contentHash: "local-script-check",
+      deleted: false,
+      data: record3.fullData
+    });
+  }
+  return {
+    manifest: documentsToProjectSchemaManifest(documents),
+    document: readDocumentArrays(
+      readPulledProjectDocumentV4(records2)
+    )
+  };
 }
 async function runScript(workspace, command, options, dependencies = {}) {
   let localCheckManifest = null;
+  let localCheckDocument = null;
   const targetsLocalMember = (command === "check" || command === "compile") && options.memberRef !== null;
   if (command === "check" && options.all || targetsLocalMember) {
-    localCheckManifest = (dependencies.analyzeWorkspaceManifest ?? analyzeWorkspaceProjectManifestV4)(workspace);
+    if (dependencies.analyzeWorkspaceManifest === void 0) {
+      const localProject = analyzeWorkspaceProjectV4(workspace);
+      localCheckManifest = localProject.manifest;
+      localCheckDocument = localProject.document;
+    } else {
+      localCheckManifest = dependencies.analyzeWorkspaceManifest(workspace);
+    }
     if (targetsLocalMember) {
       const localTarget = resolveLocalScriptMember(
         localCheckManifest,
@@ -109276,6 +109417,10 @@ async function runScript(workspace, command, options, dependencies = {}) {
       return;
     }
   }
+  if (command === "check" && options.all && localCheckManifest !== null && localCheckDocument !== null) {
+    runCheckAll(localCheckDocument, localCheckManifest, options);
+    return;
+  }
   const client = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
   const { raw } = await fetchProjectDocument(workspace);
   const document = readDocumentArrays(raw);
@@ -110219,6 +110364,7 @@ var init_script = __esm({
     init_workspace_status();
     init_source_diagnostics();
     init_project_documents();
+    init_initializer_replay();
     init_push_body_diagnostics();
     RETURN_SHORTHANDS = {
       // MemberKind numerics: Bool=1, Int=2, String=3, Float=4.
@@ -112217,6 +112363,13 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
   );
   let preparedChanges = null;
   if (options.fullValidation) {
+    onPhase("Verifying the assigned-id source rewrite\u2026");
+    materializeAssignedSchemaIdsInAuthoredSource(
+      workspace,
+      pendingAssignment.assigned,
+      status.pendingValueIdentitySites,
+      true
+    );
     onPhase("Verifying the complete source round trip\u2026");
     verifyProjectSourceCommitAgainstStateV4({
       projectId: workspace.config.projectId,
@@ -113046,17 +113199,7 @@ function rewriteFilesFromState(workspace, records2 = new Map(
       return { uri: file.path, kind, text: file.content };
     })
   );
-  const finalErrors = finalAnalysis.diagnostics.filter(
-    (diagnostic) => diagnostic.severity === "error" && !isPullRecoveryDiagnosticCode(diagnostic.code)
-  );
-  if (finalErrors.length > 0) {
-    throw new Error(
-      `Assigned-id source rewrite produced invalid source:
-${finalErrors.map(
-        (diagnostic) => `  ${diagnostic.uri}:${diagnostic.range.start.line + 1}:${diagnostic.range.start.character + 1} ${diagnostic.message}`
-      ).join("\n")}`
-    );
-  }
+  assertAssignedIdSourceRewriteValid(finalAnalysis);
   writeProjectSourceAnalysisCacheV4(workspace.root, finalAnalysis);
   const emittedPaths = new Set(files.map((file) => file.path));
   for (const recordState of Object.values(workspace.state.records)) {
@@ -113082,7 +113225,20 @@ ${finalErrors.map(
     workspace.state.records[key] = nextState;
   }
 }
-function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, pendingValueIdentitySites = /* @__PURE__ */ new Map()) {
+function assertAssignedIdSourceRewriteValid(analysis) {
+  const finalErrors = analysis.diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "error" && !isPullRecoveryDiagnosticCode(diagnostic.code)
+  );
+  if (finalErrors.length > 0) {
+    throw new Error(
+      `Assigned-id source rewrite produced invalid source:
+${finalErrors.map(
+        (diagnostic) => `  ${diagnostic.uri}:${diagnostic.range.start.line + 1}:${diagnostic.range.start.character + 1} ${diagnostic.message}`
+      ).join("\n")}`
+    );
+  }
+}
+function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, pendingValueIdentitySites = /* @__PURE__ */ new Map(), validateResult = false) {
   const pendingIdsByUri = /* @__PURE__ */ new Map();
   for (const pendingId2 of replacements.keys()) {
     if (!isPendingId(pendingId2)) continue;
@@ -113258,6 +113414,16 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
     }
     preserved.set(uri, source);
   }
+  if (validateResult && preserved.size > 0) {
+    assertAssignedIdSourceRewriteValid(
+      compileNeoProjectSources(
+        inputs.map((input) => ({
+          ...input,
+          text: preserved.get(input.uri) ?? input.text
+        }))
+      )
+    );
+  }
   return preserved;
 }
 function sourceOffsetInsideInitializer(source, oneBasedLine, oneBasedColumn) {
@@ -113874,7 +114040,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.36.2",
+      cliVersion: "0.36.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120476,7 +120642,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.36.2");
+    console.log("0.36.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

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

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

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

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

@@ -78,6 +78,11 @@ neo script eval --function Outpost.RefreshUnlock --this-value <id> --args '[3]'
 
 Prefer `--json` for automation.
 
+`neo script check --all` reconstructs the prospective project entirely from
+the local workspace. It checks local schema bodies and stored dialogue,
+migration, and text-variable bodies against that same source transaction, so
+new declarations do not depend on a prior push or a network fetch.
+
 Inside an inline Class body, unqualified names resolve against that Class;
 invoke delegate and action members directly with `Selector()` or `OnChanged()`.
 Spell a zero-argument action as bare `NeoAction`; type arguments name action
@@ -196,11 +201,13 @@ instead of hand-counting a literal or looping around `Add`:
 List<int> scores = List.Repeat(0, 10);
 ```
 
-The entry type is inferred from the value and joined with the assignment
-context, exactly like a list literal, so assigning `List.Repeat(0, 4)` to a
-`List<float>` widens the entries to `float`. Never spell type arguments on the
-qualifier: `List<int>.Repeat(0, 3)` is an error, and bare `List` is a
-qualifier, not a value.
+The entry type is normally inferred from the value and joined with the
+assignment context, exactly like a list literal, so assigning
+`List.Repeat(0, 4)` to a `List<float>` widens the entries to `float`. When the
+value cannot carry the type by itself, use a call-site type argument, for
+example `List.Repeat<InventoryItemStack?>(null, slotCount)`. Never spell type
+arguments on the qualifier: `List<int>.Repeat(0, 3)` is an error, and bare
+`List` is a qualifier, not a value.
 
 `count` must be an `int` — a `float` count is a compile error, and a negative
 count fails at runtime with `List.Repeat count must be non-negative; got