@neocompose/cli 0.62.0 → 0.62.2

package/dist/neo.mjs

@@ -19576,6 +19576,56 @@ var init_project_source_registry = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/reference-argument.ts
+function parseReferenceArgument(raw) {
+  let expression;
+  try {
+    expression = typeof raw === "string" ? parseExpression(raw) : raw;
+  } catch {
+    return null;
+  }
+  if (expression.kind === "litNull") return { kind: "none" };
+  if (expression.kind === "call") {
+    if (expression.callee.kind !== "ident" || expression.callee.name !== "Reference")
+      return null;
+    const idIndex = expression.argumentNames?.indexOf("id") ?? -1;
+    const index = idIndex < 0 ? 0 : idIndex;
+    if (expression.args.length < 1 || expression.args.length > 2) return null;
+    for (let i2 = 0; i2 < expression.args.length; i2++) {
+      const name = expression.argumentNames?.[i2];
+      if (i2 === index) {
+        if (name != null && name !== "id") return null;
+      } else if (name !== "withProvenance" || expression.args[i2]?.kind !== "litBool")
+        return null;
+    }
+    expression = expression.args[index];
+    if (expression.kind === "litString") {
+      return expression.value.length === 0 ? null : { kind: "id", value: expression.value };
+    }
+  }
+  const segments = [];
+  while (expression.kind === "member") {
+    segments.push(expression.name);
+    expression = expression.receiver;
+  }
+  if (expression.kind !== "ident" || expression.name !== "root" || segments.length === 0)
+    return null;
+  return { kind: "rootPath", value: ["root", ...segments.reverse()].join(".") };
+}
+function referenceArgumentRequirement(name) {
+  if (name === "collectionValue")
+    return '@settings collectionValue requires Reference("id") or a root path such as root.Assets.Collection.';
+  if (name === "template")
+    return '@settings template requires Reference("id") or a template symbol.';
+  return `@settings ${name} requires Reference("id").`;
+}
+var init_reference_argument = __esm({
+  "../packages/neoscript-language/src/reference-argument.ts"() {
+    "use strict";
+    init_executable_parser();
+  }
+});
+
 // ../packages/neoscript-language/src/project-schema-contract.generated.ts
 var PROJECT_FILE_UPLOAD_BATCH_SIZE, NEO_PROJECT_SOURCE_RECORD_CONTRACT;
 var init_project_schema_contract_generated = __esm({
@@ -24151,6 +24201,22 @@ function validateAnnotations(uri, annotations, context, environment, diagnostics
       if (field.name === "member" && (annotation2.name === "index" || annotation2.name === "column")) {
         continue;
       }
+      if (annotation2.name === "settings" && (field.name === "collectionValue" || field.name === "group" || field.name === "template")) {
+        const reference2 = parseReferenceArgument(argument2.text);
+        if (reference2?.kind === "none" || reference2?.kind === "id" || reference2?.kind === "rootPath" && field.name === "collectionValue")
+          continue;
+        const templateSymbol = field.name === "template" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(argument2.text.trim());
+        if (!templateSymbol) {
+          pushDiagnostic(
+            diagnostics,
+            uri,
+            argument2.range,
+            "invalid-reference-argument",
+            referenceArgumentRequirement(field.name)
+          );
+          continue;
+        }
+      }
       validateExpressionText(
         uri,
         argument2.text,
@@ -25967,6 +26033,7 @@ var NEO_VARIANT_FOLDER_SETTING, primitiveType, LIST_COLUMN_INHERITANCE_KEY, SEMA
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
+    init_reference_argument();
     init_project_source_ast();
     init_project_local_values();
     init_language_spec();
@@ -35618,8 +35685,8 @@ var init_spelling_diagnostics = __esm({
 });
 
 // ../packages/neoscript-language/src/service.ts
-function createNeoScriptLanguageService() {
-  return new LanguageService();
+function createNeoScriptLanguageService(options = {}) {
+  return new LanguageService(options);
 }
 function isProjectDocument(document, context) {
   return context?.projectSourceKind !== "spec" && (document.languageId === "neo" || document.languageId === "neoflow");
@@ -35730,6 +35797,11 @@ var init_service = __esm({
     init_syntax();
     init_test_prelude();
     LanguageService = class {
+      constructor(options) {
+        this.options = options;
+      }
+      options;
+      cachedSourceValidation;
       documents = /* @__PURE__ */ new Map();
       specSnapshots = /* @__PURE__ */ new Set();
       projectGeneration = 0;
@@ -35845,10 +35917,18 @@ var init_service = __esm({
         if (signal?.aborted) return [];
         const generation = ++state.validationGeneration;
         if (isProjectDocument(state.document, state.context)) {
-          const diagnostics = this.enhanceDiagnostics(
-            state,
-            projectDiagnostics(this.projectAnalysis(), uri)
-          );
+          const projectGeneration = this.projectGeneration;
+          const project = this.projectAnalysis();
+          const extended = await this.validateProjectSources();
+          if (projectGeneration !== this.projectGeneration) return [];
+          const diagnostics = this.enhanceDiagnostics(state, [
+            ...projectDiagnostics(project, uri),
+            ...extended.filter(
+              (diagnostic) => diagnostic.uri === uri && !project.diagnostics.some(
+                (existing) => existing.uri === uri && existing.code === diagnostic.code && existing.message === diagnostic.message && existing.range.start.line === diagnostic.range.start.line && existing.range.start.character === diagnostic.range.start.character
+              )
+            )
+          ]);
           if (signal?.aborted) return [];
           const current2 = this.documents.get(uri);
           if (!current2 || current2.validationGeneration !== generation) return [];
@@ -36051,6 +36131,31 @@ var init_service = __esm({
           )
         );
       }
+      validateProjectSources() {
+        const validate3 = this.options.validateProjectSources;
+        if (validate3 === void 0) return Promise.resolve([]);
+        if (this.cachedSourceValidation?.generation === this.projectGeneration)
+          return this.cachedSourceValidation.result;
+        const inputs = [...this.documents.values()].flatMap(
+          ({ document, context }) => isProjectDocument(document, context) ? [
+            {
+              uri: document.uri,
+              text: document.text,
+              kind: document.languageId === "neoflow" ? "flow" : context.kind === "migration" ? "migration" : "definition"
+            }
+          ] : []
+        );
+        const result = validate3(inputs).catch((error) => {
+          if (this.cachedSourceValidation?.result === result)
+            this.cachedSourceValidation = void 0;
+          throw error;
+        });
+        this.cachedSourceValidation = {
+          generation: this.projectGeneration,
+          result
+        };
+        return result;
+      }
       projectAnalysis() {
         if (this.cachedProjectAnalysis?.generation === this.projectGeneration) {
           return this.cachedProjectAnalysis.analysis;
@@ -36437,6 +36542,7 @@ var init_src = __esm({
     init_project_local_value_refactorings();
     init_cell_pattern();
     init_tile_conversion();
+    init_reference_argument();
   }
 });
 
@@ -38016,6 +38122,7 @@ var init_args = __esm({
       "generate-ids",
       "help",
       "passWithNoTests",
+      "runInBand",
       "no-verify",
       "fix",
       "yes"
@@ -38067,9 +38174,11 @@ var init_args = __esm({
       "outputFile",
       "output-file",
       "testNamePattern",
+      "maxWorkers",
       "test-timeout",
       "testTimeout",
       "passWithNoTests",
+      "runInBand",
       "no-verify"
     ]);
     TEST_ONLY_FLAGS = /* @__PURE__ */ new Set([
@@ -38077,9 +38186,11 @@ var init_args = __esm({
       "outputFile",
       "output-file",
       "testNamePattern",
+      "maxWorkers",
       "test-timeout",
       "testTimeout",
-      "passWithNoTests"
+      "passWithNoTests",
+      "runInBand"
     ]);
   }
 });
@@ -38569,8 +38680,9 @@ var init_source_diagnostics = __esm({
       "neoflow-incomplete-draft"
     ]);
     SchemaSourceError = class extends Error {
-      constructor(message, file, line, column, code, severity = "error") {
-        super(`${file}:${line}:${column} \u2014 ${message}`);
+      constructor(detail, file, line, column, code, severity = "error") {
+        super(`${file}:${line}:${column} \u2014 ${detail}`);
+        this.detail = detail;
         this.file = file;
         this.line = line;
         this.column = column;
@@ -38578,6 +38690,7 @@ var init_source_diagnostics = __esm({
         this.severity = severity;
         this.name = "SchemaSourceError";
       }
+      detail;
       file;
       line;
       column;
@@ -62319,13 +62432,23 @@ function lowerClass(context, declaration) {
         ...placement
       });
     } catch (error) {
-      if (error instanceof SchemaSourceError) throw error;
-      throw new SchemaSourceError(
+      const positioned = error instanceof SchemaSourceError ? error : new SchemaSourceError(
         error instanceof Error ? error.message : String(error),
         memberDeclaration.source.uri,
         memberDeclaration.source.range.start.line + 1,
         memberDeclaration.source.range.start.character + 1
       );
+      if (context.onDeclarationError === void 0) throw positioned;
+      context.onDeclarationError(positioned, memberDeclaration);
+      const previous = context.baseMembers.get(memberId);
+      if (previous !== void 0)
+        context.loweredMembers.set(memberId, previous);
+      else {
+        delete schema[memberDeclaration.name];
+        schemaKeyOrder.pop();
+        placements.pop();
+      }
+      continue;
     }
     const existing = context.loweredMembers.get(memberId);
     if (existing && !sameSharedMember(existing, lowered)) {
@@ -62697,7 +62820,8 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       base,
       id2,
       storesSelectionArray,
-      `${ownerClass.name}.${declaration.name}`
+      `${ownerClass.name}.${declaration.name}`,
+      !declaration.modifiers.includes("static") && contextualEnumArgument(settings, "kind") === "Unordered"
     )
   };
   const name = fieldType.name;
@@ -63558,12 +63682,12 @@ function lowerType(context, type, ownerClass) {
   if (type.name === "object") return { kind: "unknown", nullable: nullable2 };
   throw new Error(`Unknown Neo type ${JSON.stringify(type.name)}.`);
 }
-function lowerDefault(context, initializer, type, ownerClass, base, memberId, storesSelectionArray, path) {
+function lowerDefault(context, initializer, type, ownerClass, base, memberId, storesSelectionArray, path, unorderedList = false) {
   if (initializer === null) {
     return base?.defaultValue && "serverValueId" in base.defaultValue ? base.defaultValue : null;
   }
   const expression = parseExpression(initializer);
-  if (positionRequiresEvaluation(context, expression, type, ownerClass)) {
+  if (unorderedList && expression.kind === "litList" && expression.elements.length > 0 || positionRequiresEvaluation(context, expression, type, ownerClass)) {
     return {
       init: {
         code: context.settleInitializerReferences(
@@ -64715,7 +64839,15 @@ function storageChainStep(context, memberId) {
 }
 function referenceIdArgument(value, name) {
   const raw = argument(value, name);
-  return raw === null ? null : referenceId(raw);
+  if (raw === null) return null;
+  const parsed = parseReferenceArgument(raw);
+  if (parsed?.kind === "none") return null;
+  if (parsed?.kind === "id") return parsed.value;
+  if (parsed?.kind === "rootPath" && name === "collectionValue")
+    return `${PENDING_ID_PREFIX}root-path:${parsed.value}`;
+  if (name === "template" && parseAnnotationExpression(raw).kind === "ident")
+    return null;
+  throw new Error(referenceArgumentRequirement(name));
 }
 function templateSymbolArgument(context, settings, ownerClass, declaration) {
   const raw = argument(settings, "template");
@@ -64731,32 +64863,9 @@ function templateSymbolArgument(context, settings, ownerClass, declaration) {
   return templateId;
 }
 function referenceId(raw) {
-  try {
-    const expression = typeof raw === "string" ? parseExpression(raw) : raw;
-    if (expression.kind !== "call") return null;
-    if (expression.callee.kind !== "ident" || expression.callee.name !== "Reference") {
-      return null;
-    }
-    const index = expression.argumentNames?.findIndex((entry) => entry === "id") ?? -1;
-    const value = expression.args[index >= 0 ? index : 0];
-    if (value?.kind === "litString") return value.value;
-    const path = value === void 0 ? null : rootValuePath(value);
-    return path === null ? null : `${PENDING_ID_PREFIX}root-path:${path}`;
-  } catch {
-    return null;
-  }
-}
-function rootValuePath(expression) {
-  const segments = [];
-  let cursor = expression;
-  while (cursor.kind === "member") {
-    segments.unshift(cursor.name);
-    cursor = cursor.receiver;
-  }
-  if (cursor.kind !== "ident") return null;
-  if (cursor.name !== "root") return null;
-  if (segments.length === 0) return null;
-  return ["root", ...segments].join(".");
+  const parsed = parseReferenceArgument(raw);
+  if (parsed === null || parsed.kind === "none") return null;
+  return parsed.kind === "id" ? parsed.value : `${PENDING_ID_PREFIX}root-path:${parsed.value}`;
 }
 function isImpliedSchemaKeyOrder(order) {
   return order.every((key, index) => index === 0 || order[index - 1] <= key);
@@ -112398,16 +112507,8 @@ function validateDocumentInheritanceFlags(ctx) {
       const valueBearing = memberKindSupportsStorage(member.kind);
       const valueId = getField(member, "valueId");
       if (valueBearing) {
-        if (member.defaultValue != null) {
-          errors.push({
-            message: `Static member "${member.name}" (${member.id}) stores live content through valueId and cannot retain a schema defaultValue seed.`
-          });
-        }
-        if (isRequiredMember2(member) && (typeof valueId !== "string" || valueId.length === 0)) {
-          errors.push({
-            message: `Required static member "${member.name}" (${member.id}) must have an authored value binding.`
-          });
-        }
+        if (ctx.phase !== "schema")
+          errors.push(...validateStaticMemberValueBinding(member));
       } else if (member.storage != null || valueId != null || member.defaultValue != null) {
         errors.push({
           message: `Value-less static member "${member.name}" (${member.id}) cannot declare storage, valueId, or default content.`
@@ -112555,6 +112656,7 @@ function validateDocumentInheritanceFlags(ctx) {
         inheritedMetadata.declarationClassId
       );
       errors.push({
+        memberId,
         message: `Schema member "${schemaKey}" on class "${schemaClass2.name}" (${schemaClass2.id}) does not match the inherited generated signature from member "${generatedAncestorMember.name}" (${generatedAncestorMember.id}). ${schemaClass2.name}.${schemaKey} generates "${ctx.signatureProjector.format(localSignature)}" but ${declaringClass?.name ?? inheritedMetadata.memberId}.${schemaKey} declares "${ctx.signatureProjector.format(ancestorSignature)}". Abstract implementations and re-abstractions must preserve the generated member contract or have a supported codegen bridge.`
       });
     }
@@ -112633,6 +112735,23 @@ function nearestAncestorDeclaration2(schemaClass2, schemaKey, classesById) {
   }
   return null;
 }
+function validateStaticMemberValueBinding(member) {
+  if (!isStaticMember(member) || !memberKindSupportsStorage(member.kind))
+    return [];
+  const errors = [];
+  if (member.defaultValue != null)
+    errors.push({
+      memberId: member.id,
+      message: `Static member "${member.name}" (${member.id}) stores live content through valueId and cannot retain a schema defaultValue seed.`
+    });
+  const valueId = getField(member, "valueId");
+  if (isRequiredMember2(member) && (typeof valueId !== "string" || valueId.length === 0))
+    errors.push({
+      memberId: member.id,
+      message: `Required static member "${member.name}" (${member.id}) must have an authored value binding.`
+    });
+  return errors;
+}
 var init_inheritance_flags_validation = __esm({
   "../src/models/classes/inheritance-flags-validation.ts"() {
     "use strict";
@@ -114889,7 +115008,7 @@ function changesRequireInheritanceFlagsValidation(changes) {
     (change) => change.recordKind === "member" || change.recordKind === "class" || change.recordKind === "enum" || change.recordKind === "interface" || change.recordKind === "project"
   );
 }
-function assertProjectDocumentInheritanceFlagsValid(document) {
+function collectProjectDocumentInheritanceFlagsErrors(document, phase = "complete") {
   let generatedSignatures = null;
   const getGeneratedSignatures = () => {
     if (generatedSignatures !== null) return generatedSignatures;
@@ -114915,6 +115034,7 @@ function assertProjectDocumentInheritanceFlagsValid(document) {
     return generatedSignatures;
   };
   const errors = validateDocumentInheritanceFlags({
+    phase,
     members: document.members,
     classes: document.classes,
     rootMemberIds: new Set(
@@ -114939,9 +115059,11 @@ function assertProjectDocumentInheritanceFlagsValid(document) {
       hasImplementationBridge: (classId, schemaKey) => getGeneratedSignatures().hasImplementationBridge(classId, schemaKey)
     }
   });
-  if (errors.length > 0) {
-    throw new Error(errors[0].message);
-  }
+  return errors;
+}
+function assertProjectDocumentInheritanceFlagsValid(document) {
+  const errors = collectProjectDocumentInheritanceFlagsErrors(document);
+  if (errors.length > 0) throw new Error(errors[0].message);
 }
 var init_project_document_inheritance_validation = __esm({
   "../src/database/project-document-inheritance-validation.ts"() {
@@ -117435,6 +117557,103 @@ var init_client_commit_preparation = __esm({
   }
 });
 
+// src/project-source/schema-source-validation.ts
+function sourceDiagnosticMapper(analysis) {
+  const locations = /* @__PURE__ */ new Map();
+  for (const declaration of analysis.schema.classes) {
+    locations.set(
+      materializedId(declaration, "class", declaration.name),
+      declaration.source
+    );
+    for (const member of declaration.members) {
+      locations.set(
+        materializedId(member, "member", `${declaration.name}.${member.name}`),
+        member.source
+      );
+    }
+  }
+  return (error, fallback = "<project>", recordId) => {
+    const message = error instanceof SchemaSourceError ? error.detail : error instanceof Error ? error.message : String(error);
+    if (error instanceof SchemaSourceError && !error.file.startsWith("<"))
+      return error;
+    let location3 = recordId === void 0 ? void 0 : locations.get(recordId);
+    if (location3 === void 0) {
+      for (const match of message.matchAll(
+        /(__pending__:[^:\s]+:[^:\s]+:\d+:\d+:[^\s"()]*)|\(([^()]+)\)|"([^"\n]+)"/g
+      )) {
+        const id2 = match[1] ?? match[2] ?? match[3];
+        location3 = locations.get(id2);
+        if (location3 !== void 0) break;
+        const pending = /^__pending__:[^:]+:([^:]+):(\d+):(\d+):/.exec(id2);
+        if (pending !== null) {
+          const start = {
+            line: Number(pending[2]),
+            character: Number(pending[3])
+          };
+          location3 = {
+            uri: decodeURIComponent(pending[1]),
+            range: { start, end: start }
+          };
+          break;
+        }
+      }
+    }
+    if (location3 === void 0 && error instanceof SchemaSourceError)
+      return error;
+    return new SchemaSourceError(
+      message,
+      location3?.uri ?? fallback,
+      (location3?.range.start.line ?? 0) + 1,
+      (location3?.range.start.character ?? 0) + 1,
+      error instanceof SchemaSourceError ? error.code : "schema-validation"
+    );
+  };
+}
+function collectSourceSchemaErrors(document) {
+  const rootMemberIds2 = new Set(
+    PROJECT_ROOTS.map((root) => document.project[root.projectField])
+  );
+  const errors = [];
+  for (const validate3 of [
+    () => validateDocumentAccessModifiers({ ...document, rootMemberIds: rootMemberIds2 }),
+    () => collectProjectDocumentInheritanceFlagsErrors(document, "schema")
+  ]) {
+    try {
+      errors.push(...validate3());
+    } catch (error) {
+      errors.push({
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const member of document.members) {
+    if (member.kind !== 6 /* List */) continue;
+    errors.push(...validateListIndexDefinitions(document, member));
+  }
+  return errors;
+}
+function uniqueSourceErrors(errors) {
+  const seen = /* @__PURE__ */ new Set();
+  return errors.filter((error) => {
+    const key = `${error.file}:${error.line}:${error.column}:${error.detail}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+var init_schema_source_validation = __esm({
+  "src/project-source/schema-source-validation.ts"() {
+    "use strict";
+    init_project_document_inheritance_validation();
+    init_member_access_modifier_validation();
+    init_list_indexes();
+    init_member_kinds();
+    init_project2();
+    init_source_diagnostics();
+    init_lower_support();
+  }
+});
+
 // src/project-sync/value-record-comparison.ts
 function valueRecordComparisonBody(value) {
   if (!isObjectRecord2(value)) return value;
@@ -117495,7 +117714,13 @@ function lowerConfiguration(base, analysis) {
     (global) => global.type.name === "Localization"
   );
   if (!localizationGlobal) {
-    throw new Error("Format-4 source requires one Localization global.");
+    throw new SchemaSourceError(
+      "Format-4 source requires one Localization global.",
+      base.localization.source.span.path,
+      1,
+      1,
+      "missing-localization-global"
+    );
   }
   return {
     textureTemplates,
@@ -118426,6 +118651,7 @@ var wireEnumOptions, TEXTURE_TYPE_WIRE_OPTIONS, ALPHA_SOURCE_WIRE_OPTIONS, NON_P
 var init_lower_configuration = __esm({
   "src/project-source/lower-configuration.ts"() {
     "use strict";
+    init_source_diagnostics();
     init_src();
     init_lower_support();
     wireEnumOptions = () => (options) => options;
@@ -119140,6 +119366,7 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
     )
   );
   const context = {
+    onDeclarationError: options.onDeclarationError,
     base,
     baseClasses: new Map(base.classes.map((entry) => [entry.id, entry])),
     baseConstructors: new Map(
@@ -119198,17 +119425,29 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
       analysis.compiledBodies.filter((body) => body.unit === "function").map((body) => [`${body.ownerName}.${body.memberName}`, body.ir])
     )
   };
-  const classes = analysis.schema.classes.map(
-    (declaration) => lowerClass(context, declaration)
-  );
-  const constructors = analysis.schema.classes.flatMap(
-    (declaration) => lowerClassConstructors(
-      context,
-      declaration,
-      materializedId(declaration, "class", declaration.name),
-      (type, ownerClass) => lowerType(context, type, ownerClass)
-    )
-  );
+  const classes = analysis.schema.classes.flatMap((declaration) => {
+    try {
+      return [lowerClass(context, declaration)];
+    } catch (error) {
+      if (options.onDeclarationError === void 0) throw error;
+      options.onDeclarationError(error, declaration);
+      return [];
+    }
+  });
+  const constructors = analysis.schema.classes.flatMap((declaration) => {
+    try {
+      return lowerClassConstructors(
+        context,
+        declaration,
+        materializedId(declaration, "class", declaration.name),
+        (type, ownerClass) => lowerType(context, type, ownerClass)
+      );
+    } catch (error) {
+      if (options.onDeclarationError === void 0) throw error;
+      options.onDeclarationError(error, declaration);
+      return [];
+    }
+  });
   normalizeLookupDeclaredTypes(context);
   for (const [memberId, placements] of context.placements) {
     const member = context.loweredMembers.get(memberId);
@@ -123643,6 +123882,9 @@ function computeWorkspaceStatus(workspace, options) {
     staticMemberOwnershipRecoveries.filter((recovery) => recovery.action === "delete").map((recovery) => recordStateKey("member", recovery.memberId))
   );
   let manifest;
+  let rootEnvelopeValid = false;
+  let invalidSchema = false;
+  let schemaValidationDocument;
   let authoredValueSeeds = /* @__PURE__ */ new Map();
   let staticMemberValueIds = /* @__PURE__ */ new Map();
   let memberDefaults = {
@@ -123676,36 +123918,33 @@ function computeWorkspaceStatus(workspace, options) {
     }
     const analysis = options.readProjectAnalysisCache?.(workspace.root, compilationSources) ?? compileNeoProjectSources(compilationSources);
     projectAnalysisV4 = analysis;
-    for (const diagnostic of analysis.diagnostics) {
+    for (const diagnostic2 of analysis.diagnostics) {
       const positioned = new SchemaSourceError(
-        `${diagnostic.code ?? "analysis"}: ${diagnostic.message}`,
-        diagnostic.uri,
-        diagnostic.range.start.line + 1,
-        diagnostic.range.start.character + 1,
-        diagnostic.code,
-        diagnostic.severity
+        `${diagnostic2.code ?? "analysis"}: ${diagnostic2.message}`,
+        diagnostic2.uri,
+        diagnostic2.range.start.line + 1,
+        diagnostic2.range.start.character + 1,
+        diagnostic2.code,
+        diagnostic2.severity
       );
       if (positioned.severity === "error") parseErrors.push(positioned);
       else parseWarnings.push(positioned);
     }
-    if (parseErrors.some(isBlockingSchemaSourceError)) {
-      return {
-        changes: [],
-        conflictedFiles,
-        parseErrors,
-        parseWarnings,
-        reconstructed: /* @__PURE__ */ new Map(),
-        authoredValueSeeds,
-        binaryChanges: [],
-        binaryFiles: []
-      };
-    }
+    const rootDeclaration = analysis.configuration.globals.find(
+      (global) => global.type.name === "Root"
+    );
+    const rootHasCompilerError = rootDeclaration !== void 0 && analysis.diagnostics.some(
+      (error) => error.severity === "error" && error.uri === rootDeclaration.source.uri && sourceRangeContains(rootDeclaration.source.range, error.range.start)
+    );
     try {
-      validateProjectRootEnvelopeV4(
-        loweringRecords,
-        analysis,
-        valueLowerRegistry.parsedInitializers
-      );
+      if (!rootHasCompilerError) {
+        validateProjectRootEnvelopeV4(
+          loweringRecords,
+          analysis,
+          valueLowerRegistry.parsedInitializers
+        );
+        rootEnvelopeValid = true;
+      }
     } catch (error) {
       const root = analysis.configuration.globals.find(
         (global) => global.type.name === "Root"
@@ -123718,18 +123957,48 @@ function computeWorkspaceStatus(workspace, options) {
           (root?.source.range.start.character ?? 0) + 1
         )
       );
-      return {
-        changes: [],
-        conflictedFiles,
-        parseErrors,
-        parseWarnings,
-        reconstructed: /* @__PURE__ */ new Map(),
-        authoredValueSeeds,
-        binaryChanges: [],
-        binaryFiles: []
-      };
     }
-    manifest = lowerProjectSchemaV4(baseManifest, analysis, {
+    const diagnostic = sourceDiagnosticMapper(analysis);
+    const errorsByUri = /* @__PURE__ */ new Map();
+    for (const error of analysis.diagnostics) {
+      if (error.severity !== "error") continue;
+      const errors = errorsByUri.get(error.uri) ?? [];
+      errors.push(error);
+      errorsByUri.set(error.uri, errors);
+    }
+    const validAnalysis = {
+      ...analysis,
+      configuration: {
+        globals: analysis.configuration.globals.filter(
+          (global) => global.type.name !== "Root" || rootEnvelopeValid && !rootHasCompilerError
+        )
+      },
+      schema: {
+        ...analysis.schema,
+        classes: analysis.schema.classes.map((declaration) => ({
+          ...declaration,
+          members: declaration.members.filter(
+            (member) => !(errorsByUri.get(member.source.uri) ?? []).some(
+              (error) => sourceRangeContains(member.source.range, error.range.start)
+            )
+          )
+        }))
+      }
+    };
+    const failedDeclarations = /* @__PURE__ */ new Set();
+    manifest = lowerProjectSchemaV4(baseManifest, validAnalysis, {
+      onDeclarationError: (error, declaration) => {
+        failedDeclarations.add(declaration);
+        parseErrors.push(
+          error instanceof SchemaSourceError ? error : new SchemaSourceError(
+            error instanceof Error ? error.message : String(error),
+            declaration.source.uri,
+            declaration.source.range.start.line + 1,
+            declaration.source.range.start.character + 1,
+            "schema-lowering"
+          )
+        );
+      },
       staticValueIdsBySymbol: staticValueIdsBySymbol(loweringRecords),
       projectFileIdsBySymbol: projectFileIdsBySymbol(loweringRecords, analysis),
       rowBackedDefaultMemberIds: rowBackedDefaultMemberIdsV4(loweringRecords),
@@ -123737,9 +124006,61 @@ function computeWorkspaceStatus(workspace, options) {
         Object.values(loweringRecords)
       )
     });
+    try {
+      const schemaRecords = /* @__PURE__ */ new Map();
+      for (const [key, record6] of Object.entries(loweringRecords)) {
+        if (record6.recordKind !== "project") continue;
+        schemaRecords.set(key, { ...record6, deleted: false });
+      }
+      for (const record6 of projectSchemaManifestToDocuments(
+        manifest,
+        manifestToDocumentContext(baseDocuments)
+      )) {
+        schemaRecords.set(recordStateKey(record6.recordKind, record6.recordId), {
+          ...record6,
+          contentHash: "",
+          deleted: false
+        });
+      }
+      if ([...schemaRecords.values()].some(
+        (record6) => record6.recordKind === "project"
+      )) {
+        const document = readPulledProjectDocumentV4(schemaRecords);
+        schemaValidationDocument = document;
+        for (const error of collectSourceSchemaErrors(document)) {
+          parseErrors.push(
+            diagnostic(new Error(error.message), "<project>", error.memberId)
+          );
+        }
+      }
+    } catch (error) {
+      parseErrors.push(diagnostic(error));
+    }
+    invalidSchema = parseErrors.some(isBlockingSchemaSourceError);
+    const loweredMemberIds = new Set(
+      manifest.members.map((member) => member.id)
+    );
+    projectAnalysisV4 = {
+      ...validAnalysis,
+      schema: {
+        ...validAnalysis.schema,
+        classes: validAnalysis.schema.classes.map((declaration) => ({
+          ...declaration,
+          members: declaration.members.filter(
+            (member) => !failedDeclarations.has(member) && loweredMemberIds.has(
+              materializedId(
+                member,
+                "member",
+                `${declaration.name}.${member.name}`
+              )
+            )
+          )
+        }))
+      }
+    };
     memberDefaults = lowerMemberDefaultSourcesV4(
       loweringRecords,
-      analysis,
+      projectAnalysisV4,
       manifest,
       { registry: valueLowerRegistry }
     );
@@ -123759,9 +124080,17 @@ function computeWorkspaceStatus(workspace, options) {
     );
     reportPhase("analysis-schema-defaults", "Reading stored values\u2026");
   } catch (error) {
+    const missingLocalization = error instanceof SchemaSourceError && error.code === "missing-localization-global";
+    const positioned = missingLocalization ? new SchemaSourceError(
+      error.detail,
+      loweringRecords[`localization-config:${baseManifest?.localization.id}`]?.file ?? "Localization.neo",
+      1,
+      1,
+      error.code
+    ) : error;
     parseErrors.push(
-      error instanceof SchemaSourceError ? error : new SchemaSourceError(
-        error instanceof Error ? error.message : String(error),
+      positioned instanceof SchemaSourceError ? positioned : new SchemaSourceError(
+        positioned instanceof Error ? positioned.message : String(positioned),
         "<project>",
         1,
         1
@@ -123823,12 +124152,25 @@ function computeWorkspaceStatus(workspace, options) {
     ...memberDefaults.seeds
   ]);
   staticMemberValueIds = staticValues.memberValueIds;
-  const rootValues = lowerProjectRootSourceV4(
-    loweringRecords,
-    projectAnalysisV4,
-    manifest,
-    { registry: valueLowerRegistry }
-  );
+  if (schemaValidationDocument !== void 0) {
+    const diagnostic = sourceDiagnosticMapper(projectAnalysisV4);
+    for (const member of schemaValidationDocument.members) {
+      const valueId = staticMemberValueIds.get(member.id);
+      const finalized = valueId === void 0 ? member : { ...member, valueId, defaultValue: void 0 };
+      for (const error of validateStaticMemberValueBinding(finalized)) {
+        parseErrors.push(
+          diagnostic(new Error(error.message), "<project>", member.id)
+        );
+      }
+    }
+  }
+  const rootValues = rootEnvelopeValid ? lowerProjectRootSourceV4(loweringRecords, projectAnalysisV4, manifest, {
+    registry: valueLowerRegistry
+  }) : {
+    records: [],
+    memberValueIds: /* @__PURE__ */ new Map(),
+    seeds: /* @__PURE__ */ new Map()
+  };
   reportPhase("documents-static-root", "Reading variants and dialogues\u2026");
   authoredValueSeeds = new Map([...authoredValueSeeds, ...rootValues.seeds]);
   const rootPathResolutionState = overlayProspectiveSourceRecords(
@@ -124453,6 +124795,14 @@ function computeWorkspaceStatus(workspace, options) {
     }
     reportPhase("initializer-materialization");
   }
+  const mapDiagnostic = projectAnalysisV4 === null ? null : sourceDiagnosticMapper(projectAnalysisV4);
+  const positionedErrors = mapDiagnostic === null ? parseErrors : parseErrors.map((error) => mapDiagnostic(error, error.file));
+  if (invalidSchema)
+    return refusedStatus(
+      conflictedFiles,
+      uniqueSourceErrors(positionedErrors),
+      parseWarnings
+    );
   return {
     ...projectAnalysisV4 === null ? {} : {
       sourceSnapshot: {
@@ -124463,7 +124813,7 @@ function computeWorkspaceStatus(workspace, options) {
     localValues: valueLowerRegistry.localValues?.placements(),
     changes,
     conflictedFiles,
-    parseErrors,
+    parseErrors: uniqueSourceErrors(positionedErrors),
     parseWarnings,
     reconstructed: reconstructed3,
     authoredValueSeeds,
@@ -125440,10 +125790,16 @@ function refusedStatus(conflictedFiles, parseErrors, parseWarnings) {
     binaryFiles: []
   };
 }
+function sourceRangeContains(range2, position) {
+  return (position.line > range2.start.line || position.line === range2.start.line && position.character >= range2.start.character) && (position.line < range2.end.line || position.line === range2.end.line && position.character < range2.end.character);
+}
 var ANIMATION_DOCUMENT_RECORD_KINDS, ANIMATION_REPLAY_RECORD_KINDS, PROSPECTIVE_ANIMATION_RECORD_KINDS;
 var init_workspace_status_core = __esm({
   "src/project-source/workspace-status-core.ts"() {
     "use strict";
+    init_lower_support();
+    init_inheritance_flags_validation();
+    init_schema_source_validation();
     init_members();
     init_collection_binding_materialization();
     init_localizable_member_value_writes();
@@ -125566,9 +125922,9 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
   });
   const blockingErrors = status.parseErrors.filter(isBlockingSchemaSourceError);
   if (status.conflictedFiles.length > 0 || blockingErrors.length > 0) {
-    const first = blockingErrors[0];
     throw new ProjectSourceCommitVerificationError(
-      first ? `Trusted source lowering failed: ${first.file}:${first.line}:${first.column} ${first.message}` : `Trusted source lowering found conflict markers in ${status.conflictedFiles[0]}.`
+      blockingErrors.length > 0 ? `Trusted source lowering failed:
+${blockingErrors.map((error) => error.message).join("\n")}` : `Trusted source lowering found conflict markers in ${status.conflictedFiles.join(", ")}.`
     );
   }
   auditAuthoredSeedRowIdentities(
@@ -125601,8 +125957,10 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
   );
   for (const pendingId2 of assignments.keys()) {
     if (!usedAssignments.has(pendingId2)) {
+      const message = `Pending id assignment ${pendingId2} is not present in the verified source manifest.`;
+      const analysis = status.sourceSnapshot?.analysis;
       throw new ProjectSourceCommitVerificationError(
-        `Pending id assignment ${pendingId2} is not present in the verified source manifest.`
+        analysis === void 0 ? message : sourceDiagnosticMapper(analysis)(new Error(message)).message
       );
     }
   }
@@ -126096,6 +126454,7 @@ var ProjectSourceCommitVerificationError, ABSENT_DIFFERENCE_VALUE;
 var init_trusted_commit_verification = __esm({
   "src/project-source/trusted-commit-verification.ts"() {
     "use strict";
+    init_schema_source_validation();
     init_projectRecordBuckets();
     init_workspace_status_core();
     init_supplemental_records();
@@ -128480,6 +128839,8 @@ function defaultRequiresOwnedRows(context, member, sourceExpression, source) {
 }
 function memberInitializerRequiresEvaluation(context, member, expression, source) {
   if (member.kind === "class" && member.partial === true) return false;
+  if (source.purpose === "memberDefault" && member.id === source.memberId && member.kind === "list" && member.listKind === "unordered" && expression.kind === "litList" && expression.elements.length > 0)
+    return true;
   const requiresEvaluation = isSchemaMemberValueRead(context, expression, source) || initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
@@ -144934,6 +145295,113 @@ var init_project_integrity = __esm({
   }
 });
 
+// src/test-worker-pool.ts
+import { Worker as Worker5 } from "node:worker_threads";
+var TestWorkerPool;
+var init_test_worker_pool = __esm({
+  "src/test-worker-pool.ts"() {
+    "use strict";
+    TestWorkerPool = class {
+      constructor(workerUrl) {
+        this.workerUrl = workerUrl;
+      }
+      workerUrl;
+      interrupted = false;
+      workers = [];
+      failures = /* @__PURE__ */ new Map();
+      pending = /* @__PURE__ */ new Map();
+      async start(document, count) {
+        await Promise.all(
+          Array.from({ length: count }, async () => {
+            const worker = new Worker5(this.workerUrl);
+            this.workers.push(worker);
+            worker.on(
+              "error",
+              (error) => this.fail(
+                worker,
+                error instanceof Error ? error : new Error(String(error))
+              )
+            );
+            worker.on(
+              "exit",
+              (code) => this.fail(
+                worker,
+                new Error(
+                  `Test worker exited before completing its file (code ${code}).`
+                )
+              )
+            );
+            const response = await this.request(worker, { kind: "init", document });
+            if (response.kind !== "ready")
+              throw new Error("Test worker did not initialize its project.");
+          })
+        );
+      }
+      fail(worker, error) {
+        this.failures.set(worker, error);
+        this.pending.get(worker)?.(error);
+      }
+      request(worker, request) {
+        const failure = this.failures.get(worker);
+        if (failure !== void 0) return Promise.reject(failure);
+        return new Promise((resolve5, reject) => {
+          const cleanup = () => {
+            worker.off("message", onMessage);
+            this.pending.delete(worker);
+          };
+          const onMessage = (response) => {
+            cleanup();
+            if (response.kind === "error") reject(new Error(response.message));
+            else resolve5(response);
+          };
+          const onError = (error) => {
+            cleanup();
+            reject(error);
+          };
+          this.pending.set(worker, onError);
+          worker.once("message", onMessage);
+          try {
+            worker.postMessage(request);
+          } catch (error) {
+            onError(error instanceof Error ? error : new Error(String(error)));
+          }
+        });
+      }
+      async run(jobs, timeoutMs, onResult) {
+        let next = 0;
+        await Promise.all(
+          this.workers.map(async (worker) => {
+            while (!this.interrupted && next < jobs.length) {
+              const job = jobs[next++];
+              const response = await this.request(worker, {
+                kind: "run",
+                ...job,
+                timeoutMs
+              });
+              if (response.kind !== "result")
+                throw new Error("Test worker returned no file result.");
+              onResult(job.spec, response.result);
+            }
+          })
+        );
+      }
+      interrupt() {
+        this.interrupted = true;
+        for (const worker of this.workers) {
+          worker.postMessage({ kind: "interrupt" });
+        }
+      }
+      async stop() {
+        for (const reject of this.pending.values())
+          reject(new Error("Test worker stopped."));
+        await Promise.all(this.workers.map((worker) => worker.terminate()));
+        this.workers.length = 0;
+        this.failures.clear();
+      }
+    };
+  }
+});
+
 // src/neoscript-language-adapter.ts
 function createCliNeoScriptContext(options) {
   const members = [...options.documents.members];
@@ -144943,12 +145411,7 @@ function createCliNeoScriptContext(options) {
     members,
     classes: [...options.documents.classes],
     enums: [...options.documents.enums],
-    interfaces: [...options.documents.interfaces],
-    databaseVM: {
-      memberById: (id2) => members.find(
-        (member) => member.id === id2
-      ) ?? null
-    }
+    interfaces: [...options.documents.interfaces]
   };
   const compilerContext = createNeoScriptDocumentContext({
     vm,
@@ -144990,7 +145453,7 @@ async function validateCliNeoScript(uri, source, context) {
     service.closeDocument(uri);
   }
 }
-function compileCliNeoScript(uri, source, context) {
+function compileCliNeoScript(uri, source, context, projectIndex) {
   const result = compileNeoScriptStrict(
     {
       uri,
@@ -144998,7 +145461,8 @@ function compileCliNeoScript(uri, source, context) {
       version: 1,
       text: source
     },
-    context
+    context,
+    { projectIndex }
   );
   const error = result.diagnostics.find(
     (diagnostic) => diagnostic.severity === "error"
@@ -146998,7 +147462,7 @@ var init_registry2 = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.62.0",
+      cliVersion: "0.62.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -148417,8 +148881,10 @@ var init_registry2 = __esm({
 // src/commands/test.ts
 var test_exports = {};
 __export(test_exports, {
+  executeTestFile: () => executeTestFile,
   inspectNeoTestCompilation: () => inspectNeoTestCompilation,
   maintainNeoTestBuildCache: () => maintainNeoTestBuildCache,
+  prepareTestEvaluator: () => prepareTestEvaluator,
   runTest: () => runTest
 });
 import { createHash as createHash10, randomUUID as randomUUID6 } from "node:crypto";
@@ -148442,6 +148908,7 @@ import {
   resolve as resolve4,
   sep as sep8
 } from "node:path";
+import { availableParallelism } from "node:os";
 import { isDeepStrictEqual } from "node:util";
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -148763,8 +149230,28 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
   );
   return { ...candidate, documentSha256 };
 }
-function compileSpec(workspace, document, absolutePath, projectCompilationHash2) {
-  const scriptDocument = readDocumentArrays(document);
+function createSpecCompiler(document) {
+  const context = withNeoTestPrelude({
+    ...createCliNeoScriptContext({
+      documents: readDocumentArrays(document),
+      kind: "function",
+      thisClass: null
+    }),
+    kind: "function",
+    projectSourceKind: "spec",
+    returnType: { kind: "primitive", name: "void" }
+  });
+  const projectIndex = createProjectIndex(context.project);
+  return (uri, source) => compileCliNeoScript(uri, source, context, projectIndex);
+}
+function lazySpecCompiler(document) {
+  let compiler;
+  return (uri, source) => {
+    compiler ??= createSpecCompiler(document);
+    return compiler(uri, source);
+  };
+}
+function compileSpec(workspace, compile, absolutePath, projectCompilationHash2) {
   const path = relative8(workspace.root, absolutePath).split(sep8).join("/");
   const source = readFileSync19(absolutePath, "utf8");
   const sourceHash = createHash10("sha256").update(source).digest("hex");
@@ -148787,21 +149274,10 @@ function compileSpec(workspace, document, absolutePath, projectCompilationHash2)
     }
   } catch {
   }
-  const baseContext2 = createCliNeoScriptContext({
-    documents: scriptDocument,
-    kind: "function",
-    thisClass: null
-  });
-  const context = withNeoTestPrelude({
-    ...baseContext2,
-    kind: "function",
-    projectSourceKind: "spec",
-    returnType: { kind: "primitive", name: "void" }
-  });
   const compiled = {
     path,
     source,
-    action: compileCliNeoScript(`file://${absolutePath}`, source, context)
+    action: compile(`file://${absolutePath}`, source)
   };
   atomicWrite(
     artifactPath,
@@ -149481,6 +149957,18 @@ function failureFor(error, file, position, member = null) {
 function suiteHasSelectedTests(suite, selected) {
   return suite.tests.some((test) => selected.has(test.id)) || suite.suites.some((child) => suiteHasSelectedTests(child, selected));
 }
+function prepareTestEvaluator(document) {
+  sharedEvaluatorBase(document);
+}
+async function executeTestFile(spec, document, selected, timeoutMs, interrupted = () => false) {
+  return executeRegisteredSpec(
+    registerSpec(spec, document),
+    document,
+    selected,
+    timeoutMs,
+    interrupted
+  );
+}
 async function executeRegisteredSpec(registered, document, selected, timeoutMs, interrupted) {
   const results = [];
   const fileFailures = [];
@@ -149679,8 +150167,11 @@ async function runTest(workspace, options, dependencies = {}) {
   let testDurationMs = 0;
   let exitCode = 0;
   let interrupted = false;
+  let workerPool;
+  let parallelExecution = false;
   const handleSigint = () => {
     interrupted = true;
+    workerPool?.interrupt();
   };
   const assertNotInterrupted = () => {
     if (interrupted) {
@@ -149695,6 +150186,7 @@ async function runTest(workspace, options, dependencies = {}) {
     select: 0,
     compile: 0,
     register: 0,
+    workers: 0,
     execute: 0,
     finalize: 0
   };
@@ -149725,6 +150217,9 @@ async function runTest(workspace, options, dependencies = {}) {
       }
       if (candidate === null) {
         const prepared = dependencies.prepareLocalCandidate === void 0 ? await prepareLocalCandidateV4(workspace, {
+          // Tests need the compiled, validated candidate. Serializing it
+          // back to source and re-lowering is a push dry-run check.
+          fullValidation: false,
           onPhase: (label) => {
             dependencies.progress?.update(label);
           }
@@ -149776,8 +150271,9 @@ async function runTest(workspace, options, dependencies = {}) {
       );
     }
     enterPhase("compile", "Compiling test files\u2026");
+    const compile = lazySpecCompiler(rawDocument);
     specs = selectedPaths.map(
-      (path) => compileSpec(workspace, rawDocument, path, compilationHash)
+      (path) => compileSpec(workspace, compile, path, compilationHash)
     );
     let pattern = null;
     if (options.testNamePattern !== null) {
@@ -149806,21 +150302,54 @@ async function runTest(workspace, options, dependencies = {}) {
       );
     }
     const selectedIds = new Set(selectedTests.map((test) => test.id));
-    enterPhase("execute", "Running tests\u2026");
     const timeoutMs = options.timeoutMs ?? workspace.config.test?.timeoutMs ?? 5e3;
-    for (const entry of registered) {
-      const executed = await executeRegisteredSpec(
-        entry,
-        rawDocument,
-        selectedIds,
-        timeoutMs,
-        () => interrupted
-      );
+    const maxWorkers = options.maxWorkers ?? workspace.config.test?.maxWorkers ?? Math.min(4, availableParallelism());
+    if (!Number.isSafeInteger(maxWorkers) || maxWorkers <= 0) {
+      throw new NeoTestUsageError("--maxWorkers must be a positive integer.");
+    }
+    const jobs = registered.filter(
+      (entry) => (selectedTestCountByFile.get(entry.spec.path) ?? 0) > 0
+    );
+    const workerCount = options.runInBand === true ? 1 : Math.min(maxWorkers, jobs.length);
+    const recordResult = (spec, executed) => {
       results.push(...executed.tests);
       testDurationMs += executed.testDurationMs;
-      fileFailuresByPath.set(entry.spec.path, executed.failures);
+      fileFailuresByPath.set(spec.path, executed.failures);
+    };
+    if (workerCount > 1) {
+      enterPhase("workers", "Starting test workers\u2026");
+      workerPool = new TestWorkerPool(
+        new URL("./test-worker.mjs", import.meta.url)
+      );
+      await workerPool.start(rawDocument, workerCount);
       assertNotInterrupted();
+      parallelExecution = true;
+      enterPhase("execute", "Running tests\u2026");
+      await workerPool.run(
+        jobs.map((entry) => ({
+          spec: entry.spec,
+          selectedIds: entry.tests.filter((test) => selectedIds.has(test.id)).map((test) => test.id)
+        })),
+        timeoutMs,
+        recordResult
+      );
+    } else {
+      enterPhase("execute", "Running tests\u2026");
+      for (const entry of jobs) {
+        recordResult(
+          entry.spec,
+          await executeRegisteredSpec(
+            entry,
+            rawDocument,
+            selectedIds,
+            timeoutMs,
+            () => interrupted
+          )
+        );
+        assertNotInterrupted();
+      }
     }
+    assertNotInterrupted();
     if (results.some((result) => result.status === "failed") || [...fileFailuresByPath.values()].some((failures) => failures.length > 0)) {
       exitCode = 1;
     }
@@ -149828,7 +150357,7 @@ async function runTest(workspace, options, dependencies = {}) {
     const buildManifest = {
       version: 1,
       cliVersion: PROJECT_SCHEMA_CONTRACT.cliVersion,
-      runnerRevision: 3,
+      runnerRevision: 4,
       compilerRevision: NEOSCRIPT_COMPILER_REVISION,
       evaluatorRevision: 4,
       projectFingerprint,
@@ -149848,12 +150377,12 @@ async function runTest(workspace, options, dependencies = {}) {
 `
     );
   } catch (error) {
-    const diagnosticCode = error instanceof NeoTestInterruptedError ? "NEO_TEST_INTERRUPTED" : error instanceof NeoTestPreparedCandidateError ? "NEO_TEST_PREPARED_CANDIDATE" : error instanceof NeoTestUsageError ? "NEO_TEST_USAGE" : error instanceof NeoTestNoTestsError ? "NEO_TEST_NO_TESTS" : error instanceof NeoTestRegistrationError ? "NEO_TEST_REGISTRATION" : phase === "prepare" ? "NEO_TEST_PREPARATION" : phase === "compile" ? "NEO_TEST_COMPILE" : "NEO_TEST_RUNNER";
-    exitCode = error instanceof NeoTestInterruptedError ? 130 : error instanceof NeoTestUsageError || error instanceof NeoTestReportWriteError || error instanceof NeoTestPreparedCandidateError || diagnosticCode === "NEO_TEST_RUNNER" ? 2 : 1;
+    const diagnosticCode = interrupted || error instanceof NeoTestInterruptedError ? "NEO_TEST_INTERRUPTED" : error instanceof NeoTestPreparedCandidateError ? "NEO_TEST_PREPARED_CANDIDATE" : error instanceof NeoTestUsageError ? "NEO_TEST_USAGE" : error instanceof NeoTestNoTestsError ? "NEO_TEST_NO_TESTS" : error instanceof NeoTestRegistrationError ? "NEO_TEST_REGISTRATION" : phase === "prepare" ? "NEO_TEST_PREPARATION" : phase === "compile" ? "NEO_TEST_COMPILE" : "NEO_TEST_RUNNER";
+    exitCode = interrupted || error instanceof NeoTestInterruptedError ? 130 : error instanceof NeoTestUsageError || error instanceof NeoTestReportWriteError || error instanceof NeoTestPreparedCandidateError || diagnosticCode === "NEO_TEST_RUNNER" ? 2 : 1;
     diagnostics.push({
       severity: "error",
       code: diagnosticCode,
-      message: errorMessage2(error),
+      message: interrupted ? "Neo test was interrupted by SIGINT; partial results were written." : errorMessage2(error),
       file: null,
       line: null,
       column: null,
@@ -149861,6 +150390,7 @@ async function runTest(workspace, options, dependencies = {}) {
     });
   }
   finishPhase();
+  await workerPool?.stop();
   dependencies.progress?.stop();
   process.off("SIGINT", handleSigint);
   const failed = results.filter((result) => result.status === "failed").length;
@@ -149870,21 +150400,33 @@ async function runTest(workspace, options, dependencies = {}) {
   );
   const skipped = Math.max(0, selectedTestTotal - results.length);
   const durationMs = performance.now() - performanceStarted;
-  const startupDurationMs = Math.max(0, durationMs - testDurationMs);
+  const startupDurationMs = parallelExecution ? Math.max(0, durationMs - phaseDurations.execute) : Math.max(0, durationMs - testDurationMs);
   const perTestStartupDurationMs = results.reduce(
     (sum, result) => sum + result.startupDurationMs,
     0
   );
   const sharedStartupDurationMs = Math.max(
     0,
-    startupDurationMs - perTestStartupDurationMs
+    startupDurationMs - (parallelExecution ? 0 : perTestStartupDurationMs)
   );
+  const testsByFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const tests = testsByFile.get(result.file) ?? [];
+    tests.push(result);
+    testsByFile.set(result.file, tests);
+  }
   const testFiles = specs.map((spec) => {
-    const tests = results.filter((result) => result.file === spec.path);
+    const tests = testsByFile.get(spec.path) ?? [];
     const failures = fileFailuresByPath.get(spec.path) ?? [];
+    let status = "passed";
+    if (tests.some((test) => test.status === "failed") || failures.length > 0) {
+      status = "failed";
+    } else if (tests.length < (selectedTestCountByFile.get(spec.path) ?? 0) && exitCode !== 0) {
+      status = interrupted ? "interrupted" : "failed";
+    }
     return {
       path: spec.path,
-      status: tests.some((test) => test.status === "failed") || failures.length > 0 ? "failed" : interrupted && tests.length < (selectedTestCountByFile.get(spec.path) ?? 0) ? "interrupted" : "passed",
+      status,
       tests,
       failures
     };
@@ -149920,6 +150462,7 @@ async function runTest(workspace, options, dependencies = {}) {
       selectMs: phaseDurations.select,
       compileMs: phaseDurations.compile,
       registerMs: phaseDurations.register,
+      workerStartupMs: phaseDurations.workers,
       executeMs: phaseDurations.execute,
       finalizeMs: phaseDurations.finalize
     },
@@ -150001,8 +150544,9 @@ async function runTest(workspace, options, dependencies = {}) {
     console.log(
       ` ${color.bold(pad("Tests", 11))} ${formatStatusCounts(report.summary.passed, report.summary.failed, report.summary.tests, report.summary.skipped)}`
     );
+    const timingDetail = parallelExecution ? `test work ${formatTestDuration(report.summary.testDurationMs)}, execution ${formatTestDuration(report.timings.executeMs)}, startup ${formatTestDuration(report.summary.startupDurationMs)}` : `test ${formatTestDuration(report.summary.testDurationMs)}, startup ${formatTestDuration(report.summary.startupDurationMs)}`;
     console.log(
-      ` ${color.bold(pad("Duration", 11))} ${color.bold(`total ${formatTestDuration(report.summary.durationMs)}`)} ${color.dim(`(test ${formatTestDuration(report.summary.testDurationMs)}, startup ${formatTestDuration(report.summary.startupDurationMs)})`)}`
+      ` ${color.bold(pad("Duration", 11))} ${color.bold(`total ${formatTestDuration(report.summary.durationMs)}`)} ${color.dim(`(${timingDetail})`)}`
     );
   }
   if (!report.success) process.exitCode = exitCode;
@@ -150032,9 +150576,10 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
     document
   );
   const errors = [];
+  const compile = lazySpecCompiler(document);
   for (const path of selectedPaths) {
     try {
-      compileSpec(workspace, document, path, compilationHash);
+      compileSpec(workspace, compile, path, compilationHash);
     } catch (error) {
       errors.push({
         file: relative8(workspace.root, path).split(sep8).join("/"),
@@ -150053,6 +150598,7 @@ var TEST_BUILD_CACHE_LIMIT_BYTES, ABANDONED_TEMP_MAX_AGE_MS, TEST_CANDIDATE_CACH
 var init_test = __esm({
   "src/commands/test.ts"() {
     "use strict";
+    init_test_worker_pool();
     init_src();
     init_members();
     init_neoscript2();
@@ -155591,6 +156137,11 @@ ${h("Usage")}
   neo test ${d("[file-or-directory ...]")}
   neo test -t ${d('"name pattern"')}
   neo test ${d("--reporter=json --outputFile=output.json")}
+  neo test ${d("--maxWorkers=4")}
+  neo test ${d("--runInBand")}
+
+Files run in parallel, using up to four available CPU workers by default.
+--maxWorkers overrides neo.json test.maxWorkers; --runInBand runs serially.
 
 Tests execute against the locally compiled candidate graph, including changes
 that have not been pushed. Test files are never included in a push.
@@ -155678,7 +156229,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.62.0");
+    console.log("0.62.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -156004,6 +156555,11 @@ async function main() {
           "--testTimeout must be a positive number of milliseconds."
         );
       }
+      const maxWorkersValue = stringFlag(args, "maxWorkers");
+      const maxWorkers = maxWorkersValue === null ? void 0 : Number(maxWorkersValue);
+      if (maxWorkers !== void 0 && (!Number.isSafeInteger(maxWorkers) || maxWorkers <= 0)) {
+        throw new NeoCliUsageError("--maxWorkers must be a positive integer.");
+      }
       const progress = reporterValue === "default" && process.stdout.isTTY === true ? spinner("Reading local workspace\u2026") : null;
       try {
         const workspace = loadWorkspaceForCommand(args);
@@ -156016,6 +156572,8 @@ async function main() {
             reporter: reporterValue,
             outputFile: stringFlag(args, "outputFile") ?? stringFlag(args, "output-file"),
             passWithNoTests: boolFlag(args, "passWithNoTests"),
+            runInBand: boolFlag(args, "runInBand"),
+            ...maxWorkers === void 0 ? {} : { maxWorkers },
             ...timeoutMs === void 0 ? {} : { timeoutMs }
           },
           progress === null ? {} : { progress }