@neocompose/cli 0.36.1 → 0.36.3

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [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
+
+- Report invalid ordinary member initializers at their authored file and token
+  in the CLI and editor. C# numeric suffixes such as `0f` now explain that the
+  suffix should be removed instead of surfacing as `<project>:1:1` with an EOF
+  parser error.
+- Accept `null` as the literal default of a nullable `NeoDelegate`, preventing
+  valid pending delegate members from failing prospective project,
+  initializer-materialization, and animation validation.
+
 ## [0.36.1] - 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);
@@ -22973,7 +23034,15 @@ function validateDeclaration(uri, declaration, documentKind, environment, diagno
     scope.set(member.name, semanticType(member.type));
   }
   for (const member of declaration.members) {
-    validateMember(uri, member, documentKind, scope, environment, diagnostics);
+    validateMember(
+      uri,
+      member,
+      declaration.name,
+      documentKind,
+      scope,
+      environment,
+      diagnostics
+    );
   }
   if (declaration.kind === "class") {
     validateRetiredParameterReads(uri, declaration, scope, diagnostics);
@@ -23243,7 +23312,7 @@ function slotPosition(start, pos) {
   }
   return { line: start.line + pos.line - 1, character: pos.column - 1 };
 }
-function validateMember(uri, member, documentKind, ownerScope, environment, diagnostics) {
+function validateMember(uri, member, ownerName, documentKind, ownerScope, environment, diagnostics) {
   const memberType2 = semanticType(member.type);
   validateAnnotations(
     uri,
@@ -23285,7 +23354,11 @@ function validateMember(uri, member, documentKind, ownerScope, environment, diag
       environment,
       member.initializer.range,
       diagnostics,
-      anchorOf(member.initializer)
+      anchorOf(member.initializer),
+      {
+        code: "invalid-project-member-initializer",
+        label: `Member '${ownerName}.${member.name}' initializer`
+      }
     );
   }
   if (documentKind === "flow" && member.flowInitializer?.body?.kind === "block") {
@@ -23789,7 +23862,7 @@ function settingsClassFields(name) {
 function anchorOf(source) {
   return { text: source.text, start: source.range.start };
 }
-function validateExpressionText(uri, text, expected, scope, environment, range2, diagnostics, anchor) {
+function validateExpressionText(uri, text, expected, scope, environment, range2, diagnostics, anchor, syntaxDiagnostic) {
   try {
     validateExpression(
       parseExpression(text),
@@ -23803,7 +23876,37 @@ function validateExpressionText(uri, text, expected, scope, environment, range2,
     );
   } catch (error) {
     if (!(error instanceof CompileError)) throw error;
+    if (syntaxDiagnostic !== void 0) {
+      const errorRange = anchor === void 0 ? range2 : anchorSpan(
+        anchor,
+        { line: error.line, column: error.column },
+        anchorOffset(anchor, error) < text.length ? 1 : 0
+      );
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        errorRange,
+        syntaxDiagnostic.code,
+        memberInitializerSyntaxMessage(syntaxDiagnostic.label, text, error)
+      );
+      return;
+    }
+  }
+}
+function memberInitializerSyntaxMessage(label, text, error) {
+  const anchor = {
+    text,
+    start: { line: 0, character: 0 }
+  };
+  const offset = anchorOffset(anchor, error);
+  const suffix = text[offset];
+  const previous = text[offset - 1];
+  const next = text[offset + 1];
+  if (suffix !== void 0 && previous !== void 0 && /[fFdDmM]/u.test(suffix) && /[0-9]/u.test(previous) && (next === void 0 || !/[A-Za-z0-9_]/u.test(next))) {
+    return `${label} uses unsupported C# numeric suffix '${suffix}'. NeoScript numeric literals do not use suffixes; remove '${suffix}'.`;
   }
+  const detail = error.message.replace(/^\d+:\d+:\s*/u, "");
+  return `${label} could not be parsed: ${detail}`;
 }
 function validateFunctionBody(uri, text, returnType, scope, environment, range2, diagnostics) {
   try {
@@ -32561,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,
@@ -32897,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;
@@ -33433,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",
@@ -44538,6 +44642,7 @@ function isMemberDelegateBase(value) {
   if (defaultValue === void 0 || defaultValue === null) return true;
   if (!isMemberValueBase(defaultValue)) return false;
   if (isInitValueContent(defaultValue)) return true;
+  if (defaultValue.value === null) return v.required === false;
   return isNSDelegateValue(defaultValue.value);
 }
 function nsActionListenerIdentity(listener) {
@@ -61723,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;
@@ -61970,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
@@ -61989,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
       };
@@ -62994,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;
@@ -63596,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(
@@ -63696,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 } : {}
     };
   }
@@ -91957,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") {
@@ -92216,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) {
@@ -92237,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])
   );
@@ -92367,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,
@@ -92921,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,
@@ -94841,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) {
@@ -95482,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
     })),
@@ -95542,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(
@@ -95868,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) {
@@ -97274,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;
@@ -109182,7 +109334,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
   });
@@ -109207,13 +109359,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,
@@ -109233,6 +109407,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);
@@ -110176,6 +110354,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.
@@ -113831,7 +114010,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.36.1",
+      cliVersion: "0.36.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120433,7 +120612,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.1");
+    console.log("0.36.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.36.1",
+  "version": "0.36.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.36.1 -->
+<!-- reviewed-through-cli: 0.36.3 -->
 
 # 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.1 -->
+<!-- reviewed-through-cli: 0.36.3 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -154,6 +154,10 @@ components must be numeric literals. When a computed list or dictionary entry
 carries an authored `@id`, parenthesize the expression — `@id("row")
 (A.B / A.C)` — so the annotation names the row rather than its left operand.
 
+Numeric literals do not use C# suffixes: write `0` or `0.5`, not `0f` or
+`0.5f`. The declared/contextual type determines whether a literal is stored as
+an int, float, or decimal.
+
 A direct field or property read is computed too, whether it is local,
 qualified static, or reached through a stable root path. For example,
 `protected int Slots = FeatureFlags.StartInventorySize;` evaluates the current

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