@neocompose/cli 0.26.2 → 0.26.4

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.26.4] - 2026-08-10
+
+### Fixed
+
+- Read an omitted nullable member on a newly constructed class as `null`
+  instead of throwing a missing-object-key error. `neo test` can now assert
+  explicit nullable defaults without requiring an otherwise-empty value row.
+- Let local candidate validation resolve an image or audio file created in the
+  same source change. `neo doctor`, `neo test`, and push dry runs now preserve
+  the pending file identity while rehearsing the uploaded project-file row.
+
+## [0.26.3] - 2026-08-10
+
+### Changed
+
+- Show a phase-aware loading spinner during interactive `neo test` runs, then
+  render files, tests, failures, counts, and durations with Vitest-style
+  grouping, alignment, color, and emphasis. JSON reports now expose prepare,
+  selection, compilation, registration, execution, and finalization timings.
+- Reuse matcher dispatch metadata, build assertion diagnostics only on failure,
+  and compare structured values directly instead of serializing them to JSON.
+  This keeps successful `expect`, `toBe`, `toEqual`, `toHaveLength`,
+  `toContain`, `toMatchObject`, and mock assertions on a smaller hot path.
+
 ## [0.26.2] - 2026-08-10
 
 ### Changed

package/dist/neo.mjs

@@ -169,6 +169,9 @@ function warn(text) {
 function note(text) {
   console.log(color.dim(text));
 }
+function pad(text, width) {
+  return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
 function paintChangeKind(kind) {
   const painter = CHANGE_KIND_COLOR[kind];
   return painter === void 0 ? kind : painter(kind);
@@ -46689,9 +46692,9 @@ ${namedArguments(
 `;
 }
 function namedArguments(entries, spaces, raw = /* @__PURE__ */ new Set()) {
-  const pad = " ".repeat(spaces);
+  const pad2 = " ".repeat(spaces);
   return entries.map(
-    ([name, value]) => `${pad}${name}: ${raw.has(name) ? rawValue(value) : jsonValue2(value)},`
+    ([name, value]) => `${pad2}${name}: ${raw.has(name) ? rawValue(value) : jsonValue2(value)},`
   ).join("\n");
 }
 function rawValue(value) {
@@ -57376,6 +57379,13 @@ var init_NeoScriptScope = __esm({
       setLocal(bindingId, value) {
         this.#bindings.set(bindingId, value);
       }
+      bindInvocationEntry(bindingId, value) {
+        this.#bindings.set(bindingId, value);
+      }
+      bindInvocationKeyAndEntry(keyBindingId, key, entryBindingId, entry) {
+        this.#bindings.set(keyBindingId, key);
+        this.#bindings.set(entryBindingId, entry);
+      }
       resetInvocationLocals(parameterCount) {
         if (this.#bindings.size > parameterCount) this.#bindings.clear();
         if (this.#readonlyBindingErrors.size > 0) {
@@ -61898,6 +61908,7 @@ function dispatchSchemaMember(receiver, schemaKey, ctx) {
     };
   }
   if (!Object.prototype.hasOwnProperty.call(receiver, schemaKey)) {
+    if (!member.required) return { kind: "ok", value: null };
     return { kind: "no-info", matchedMember: true };
   }
   const at = receiver[schemaKey];
@@ -62423,6 +62434,211 @@ function evalDeclaredListIndex(info, scope, ctx) {
   }
   return Array.isArray(hit) ? [...hit] : [];
 }
+function prepareCollectionCallback(callback, parentScope, ctx, isList, returnContract, onPredicateMatch) {
+  const metrics = ctx.__collectionCallbackPreparationMetrics;
+  if (metrics !== void 0) metrics.bodyValidations += 1;
+  const compilerRevision = callback.compilerRevision ?? 1;
+  if (!Number.isSafeInteger(compilerRevision)) {
+    throw new NSGetterRuntimeError(
+      "Collection callback compiler revision must be a safe integer."
+    );
+  }
+  if (compilerRevision < 1) {
+    throw new NSGetterRuntimeError(
+      "Collection callback compiler revision must be at least 1."
+    );
+  }
+  if (compilerRevision > NEOSCRIPT_COMPILER_REVISION) {
+    throw new NSGetterRuntimeError(
+      `Collection callback compiler revision ${String(compilerRevision)} is newer than supported revision ${String(NEOSCRIPT_COMPILER_REVISION)}.`
+    );
+  }
+  if (!isNSFunctionWithReturnType(callback)) {
+    throw new NSGetterRuntimeError(
+      `Collection callback body metadata is invalid for compiler revision ${String(compilerRevision)}.`
+    );
+  }
+  const parameters = callback.parameters;
+  if (parameters.length < 1) {
+    throw new NSGetterRuntimeError(
+      "Collection callback requires at least one parameter."
+    );
+  }
+  if (parameters.length > 2) {
+    throw new NSGetterRuntimeError(
+      `Collection callback supports at most two parameters, but received ${String(parameters.length)}.`
+    );
+  }
+  if (returnContract === "predicate") {
+    if (callback.typeInfo.type !== 1 /* Bool */) {
+      throw new NSGetterRuntimeError(
+        "Collection predicate callback must declare a Bool return type."
+      );
+    }
+    if (!callback.typeInfo.required) {
+      throw new NSGetterRuntimeError(
+        "Collection predicate callback must declare a required return type."
+      );
+    }
+  }
+  const parameterCount = parameters.length;
+  const callbackScope = ctx.__collectionCallbackStrategy === "fresh" ? null : createChildScope(parentScope);
+  const callbackOptions = evaluationOptions(ctx, false);
+  const instructions = callback.instructions;
+  const returnTypeInfo = callback.typeInfo;
+  const requiresInvocationReset = callbackBodyMayAddInvocationLocals(
+    instructions,
+    new Set(parameters.map((parameter4) => parameter4.id))
+  );
+  let finishBody;
+  if (returnContract === "predicate") {
+    finishBody = (innerScope2) => {
+      const result = evalInstructions(
+        instructions,
+        innerScope2,
+        ctx,
+        callbackOptions
+      );
+      rejectEscapedLoopTransfer(result, "collection callback");
+      if (result.kind !== "return") {
+        throw new NSGetterRuntimeError(
+          "Collection callback ended without returning a value."
+        );
+      }
+      const value = result.value;
+      if (typeof value !== "boolean") {
+        throw new NSGetterRuntimeError(
+          "Collection predicate callback returned a value that does not match its required Bool contract."
+        );
+      }
+      return value;
+    };
+  } else {
+    finishBody = (innerScope2) => {
+      const result = evalInstructions(
+        instructions,
+        innerScope2,
+        ctx,
+        callbackOptions
+      );
+      rejectEscapedLoopTransfer(result, "collection callback");
+      if (result.kind !== "return") {
+        throw new NSGetterRuntimeError(
+          "Collection callback ended without returning a value."
+        );
+      }
+      let value = result.value;
+      if (returnTypeInfo.type === 20 /* Decimal */ && typeof value === "number") {
+        value = coerceDecimalOperand(value, "collection callback return");
+      }
+      if (!runtimeValueMatchesType(value, returnTypeInfo, ctx)) {
+        throw new NSGetterRuntimeError(
+          "Collection projection callback returned a value that does not match its compiled return type."
+        );
+      }
+      return value;
+    };
+  }
+  if (metrics !== void 0) metrics.bindingPlanCreations += 1;
+  if (ctx.__collectionCallbackStrategy === "fresh" || ctx.__collectionCallbackStrategy === "prepared") {
+    return (entry, key, valueId) => {
+      if (onPredicateMatch !== void 0) {
+        consumeBudget(ctx, "workUnits", 1, "work unit");
+      }
+      const innerScope2 = callbackScope ?? createChildScope(parentScope);
+      if (callbackScope !== null) {
+        callbackScope.resetInvocationLocals(parameterCount);
+      }
+      if (parameters.length === 1) {
+        innerScope2.setLocal(parameters[0].id, entry);
+      } else if (parameters.length === 2) {
+        innerScope2.setLocal(
+          parameters[0].id,
+          isList ? Number(key) : String(key)
+        );
+        innerScope2.setLocal(parameters[1].id, entry);
+      }
+      const value = finishBody(innerScope2);
+      if (onPredicateMatch === void 0) return value;
+      return value === true ? onPredicateMatch(entry, key, valueId) : 0 /* Continue */;
+    };
+  }
+  const innerScope = callbackScope ?? createChildScope(parentScope);
+  let bindValues;
+  if (parameterCount === 1) {
+    const entryParameterId = parameters[0].id;
+    bindValues = (entry) => {
+      innerScope.bindInvocationEntry(entryParameterId, entry);
+    };
+  } else {
+    const keyParameterId = parameters[0].id;
+    const entryParameterId = parameters[1].id;
+    bindValues = (entry, key) => {
+      innerScope.bindInvocationKeyAndEntry(
+        keyParameterId,
+        key,
+        entryParameterId,
+        entry
+      );
+    };
+  }
+  if (returnContract === "predicate") {
+    if (onPredicateMatch === void 0) {
+      throw new NSGetterRuntimeError(
+        "Collection predicate preparation requires a match handler."
+      );
+    }
+    if (requiresInvocationReset) {
+      return (entry, key, valueId) => {
+        consumeBudget(ctx, "workUnits", 1, "work unit");
+        innerScope.resetInvocationLocals(parameterCount);
+        bindValues(entry, key);
+        return finishBody(innerScope) === true ? onPredicateMatch(entry, key, valueId) : 0 /* Continue */;
+      };
+    }
+    return (entry, key, valueId) => {
+      consumeBudget(ctx, "workUnits", 1, "work unit");
+      bindValues(entry, key);
+      return finishBody(innerScope) === true ? onPredicateMatch(entry, key, valueId) : 0 /* Continue */;
+    };
+  }
+  if (requiresInvocationReset) {
+    return (entry, key) => {
+      innerScope.resetInvocationLocals(parameterCount);
+      bindValues(entry, key);
+      return finishBody(innerScope);
+    };
+  }
+  return (entry, key) => {
+    bindValues(entry, key);
+    return finishBody(innerScope);
+  };
+}
+function callbackBodyMayAddInvocationLocals(instructions, parameterIds) {
+  return instructions.some((instruction) => {
+    switch (instruction.type) {
+      case "variable" /* variable */:
+        return !parameterIds.has(instruction.variable.id);
+      case "assign" /* assign */:
+        return instruction.target.pointer.type === "variable" /* variable */ && !parameterIds.has(instruction.target.pointer.variableId);
+      case "if" /* if */:
+      case "for" /* for */:
+      case "forEach" /* forEach */:
+      case "switch" /* switch */:
+      case "try" /* try */:
+        return true;
+      default:
+        return false;
+    }
+  });
+}
+function isListCollection(collection) {
+  if (Array.isArray(collection)) return true;
+  if (typeof collection === "object" && collection !== null) return false;
+  throw new NSGetterRuntimeError(
+    "Collection callback receiver must be a present List or Dictionary value."
+  );
+}
 function evalFunction(fn, scope, ctx) {
   switch (fn.type) {
     case "classConstructor" /* classConstructor */:
@@ -62609,34 +62825,15 @@ function evalFunction(fn, scope, ctx) {
     case "where" /* where */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
       const innerFn = fn.info.function;
-      const isList = Array.isArray(c);
+      const isList = isListCollection(c);
       const out = isList ? [] : {};
-      const useFreshCallbackScope = ctx.__collectionCallbackStrategy === "fresh";
-      const callbackScope = useFreshCallbackScope ? null : createChildScope(scope);
-      const callbackOptions = useFreshCallbackScope ? null : evaluationOptions(ctx, false);
-      const callbackParameterCount = innerFn.parameters.length === 1 || innerFn.parameters.length === 2 ? innerFn.parameters.length : 0;
-      iterateCollection(c, ctx, (entry, key, valueId) => {
-        consumeBudget(ctx, "workUnits", 1, "work unit");
-        const innerScope = callbackScope ?? pushParams(scope, innerFn.parameters, [key, entry], isList);
-        if (callbackScope !== null) {
-          callbackScope.resetInvocationLocals(callbackParameterCount);
-          if (callbackParameterCount === 1) {
-            callbackScope.setLocal(innerFn.parameters[0].id, entry);
-          } else if (callbackParameterCount === 2) {
-            callbackScope.setLocal(
-              innerFn.parameters[0].id,
-              isList ? Number(key) : String(key)
-            );
-            callbackScope.setLocal(innerFn.parameters[1].id, entry);
-          }
-        }
-        const result = evalInstructions(
-          innerFn.instructions,
-          innerScope,
-          ctx,
-          callbackOptions ?? evaluationOptions(ctx, false)
-        );
-        if (result.kind === "return" && result.value === true) {
+      const callback = prepareCollectionCallback(
+        innerFn,
+        scope,
+        ctx,
+        isList,
+        "predicate",
+        (entry, key, valueId) => {
           consumeBudget(
             ctx,
             "producedCollectionEntries",
@@ -62648,53 +62845,38 @@ function evalFunction(fn, scope, ctx) {
           } else {
             out[String(key)] = valueId ?? entry;
           }
+          return 0 /* Continue */;
         }
-        return 0 /* Continue */;
-      });
+      );
+      iterateCollection(c, ctx, callback);
       return out;
     }
     case "first" /* first */:
     case "firstOrDefault" /* firstOrDefault */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
       const innerFn = fn.info.function ?? null;
-      const isList = Array.isArray(c);
+      const isList = isListCollection(c);
       const sentinel = /* @__PURE__ */ Symbol("not-found");
-      const useFreshCallbackScope = ctx.__collectionCallbackStrategy === "fresh";
-      const callbackScope = innerFn === null || useFreshCallbackScope ? null : createChildScope(scope);
-      const callbackOptions = innerFn === null || useFreshCallbackScope ? null : evaluationOptions(ctx, false);
-      const callbackParameterCount = innerFn !== null && (innerFn.parameters.length === 1 || innerFn.parameters.length === 2) ? innerFn.parameters.length : 0;
       let found = sentinel;
-      iterateCollection(c, ctx, (entry, key) => {
-        if (innerFn === null) {
+      if (innerFn === null) {
+        iterateCollection(c, ctx, (entry) => {
           found = entry;
           return 1 /* Break */;
-        }
-        consumeBudget(ctx, "workUnits", 1, "work unit");
-        const innerScope = callbackScope ?? pushParams(scope, innerFn.parameters, [key, entry], isList);
-        if (callbackScope !== null) {
-          callbackScope.resetInvocationLocals(callbackParameterCount);
-          if (callbackParameterCount === 1) {
-            callbackScope.setLocal(innerFn.parameters[0].id, entry);
-          } else if (callbackParameterCount === 2) {
-            callbackScope.setLocal(
-              innerFn.parameters[0].id,
-              isList ? Number(key) : String(key)
-            );
-            callbackScope.setLocal(innerFn.parameters[1].id, entry);
-          }
-        }
-        const result = evalInstructions(
-          innerFn.instructions,
-          innerScope,
+        });
+      } else {
+        const callback = prepareCollectionCallback(
+          innerFn,
+          scope,
           ctx,
-          callbackOptions ?? evaluationOptions(ctx, false)
+          isList,
+          "predicate",
+          (entry) => {
+            found = entry;
+            return 1 /* Break */;
+          }
         );
-        if (result.kind === "return" && result.value === true) {
-          found = entry;
-          return 1 /* Break */;
-        }
-        return 0 /* Continue */;
-      });
+        iterateCollection(c, ctx, callback);
+      }
       if (found !== sentinel) return found;
       if (fn.type === "first" /* first */) {
         throw new NSGetterRuntimeError(
@@ -62705,43 +62887,26 @@ function evalFunction(fn, scope, ctx) {
     }
     case "select" /* select */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
-      const useFreshCallbackScope = ctx.__collectionCallbackStrategy === "fresh";
-      const callbackScope = useFreshCallbackScope ? null : createChildScope(scope);
-      const callbackOptions = useFreshCallbackScope ? null : evaluationOptions(ctx, false);
       const innerFn = fn.info.function;
-      const callbackParameterCount = innerFn.parameters.length === 1 || innerFn.parameters.length === 2 ? innerFn.parameters.length : 0;
-      const isList = Array.isArray(c);
+      const isList = isListCollection(c);
+      const callback = prepareCollectionCallback(
+        innerFn,
+        scope,
+        ctx,
+        isList,
+        "projection"
+      );
       const out = [];
-      iterateCollection(c, ctx, (entry, key) => {
+      iterateCollection(c, ctx, (entry, key, valueId) => {
         consumeBudget(ctx, "workUnits", 1, "work unit");
-        const innerScope = callbackScope ?? pushParams(scope, innerFn.parameters, [key, entry], isList);
-        if (callbackScope !== null) {
-          callbackScope.resetInvocationLocals(callbackParameterCount);
-          if (callbackParameterCount === 1) {
-            callbackScope.setLocal(innerFn.parameters[0].id, entry);
-          } else if (callbackParameterCount === 2) {
-            callbackScope.setLocal(
-              innerFn.parameters[0].id,
-              isList ? Number(key) : String(key)
-            );
-            callbackScope.setLocal(innerFn.parameters[1].id, entry);
-          }
-        }
-        const result = evalInstructions(
-          innerFn.instructions,
-          innerScope,
+        const value = callback(entry, key, valueId);
+        consumeBudget(
           ctx,
-          callbackOptions ?? evaluationOptions(ctx, false)
+          "producedCollectionEntries",
+          1,
+          "produced collection entry"
         );
-        if (result.kind === "return") {
-          consumeBudget(
-            ctx,
-            "producedCollectionEntries",
-            1,
-            "produced collection entry"
-          );
-          out.push(result.value);
-        }
+        out.push(value);
         return 0 /* Continue */;
       });
       return out;
@@ -65294,17 +65459,6 @@ function iterateCollection(c, ctx, callback) {
     return callback(entry, key, valueId);
   });
 }
-function pushParams(parent, parameters, positional, isList) {
-  const child = createChildScope(parent);
-  if (parameters.length === 1) {
-    child.setLocal(parameters[0].id, positional[1]);
-  } else if (parameters.length === 2) {
-    const first = isList ? Number(positional[0]) : String(positional[0]);
-    child.setLocal(parameters[0].id, first);
-    child.setLocal(parameters[1].id, positional[1]);
-  }
-  return child;
-}
 var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptResourceLimitError, NeoScriptWallClockTimeoutError, DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, resolutionCacheByMembers, NO_SCHEMA_REVISION, LazyValueOverlay, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
 var init_evaluateNSGetter = __esm({
   "../src/view-models/neoscript-evaluator/evaluateNSGetter.ts"() {
@@ -65318,6 +65472,7 @@ var init_evaluateNSGetter = __esm({
     init_neoscript();
     init_NSGetterRuntimeError();
     init_value_row_owner_members();
+    init_src();
     init_decimal();
     init_members();
     init_core();
@@ -83124,6 +83279,15 @@ function applyProjectVersionWriteChanges(document, changes) {
       "constructor"
     ),
     values: applyArrayChanges(document.values ?? [], changes, "value"),
+    // Project-file staging finalizes pending uploads before schema
+    // preparation. Defaults and authored instance graphs may reference a file
+    // created by the same source transaction, so every construction pass must
+    // see that finalized row in its post-write document.
+    projectFiles: applyArrayChanges(
+      document.projectFiles ?? [],
+      changes,
+      "project-file"
+    ),
     internalRecordRelations: applyArrayChanges(
       document.internalRecordRelations ?? [],
       changes,
@@ -100901,7 +101065,11 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
     );
     preparedChanges = assertServerPreparationSucceeds({
       workspace,
-      changes: transportChanges,
+      changes: completeLocallyStagedProjectFileChanges({
+        projectId: workspace.config.projectId,
+        changes: transportChanges,
+        stagedRecordIds: new Set(preparedFiles.map((file) => file.recordId))
+      }),
       authoredValueSeeds: transportSeeds,
       sourceByRecord: status.reconstructed,
       localInitializerMaterialization: pendingAssignment.localInitializerMaterialization,
@@ -101024,6 +101192,33 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
     preparedLocal
   };
 }
+function completeLocallyStagedProjectFileChanges(args) {
+  return args.changes.map((change) => {
+    if (!args.stagedRecordIds.has(change.recordId)) return change;
+    if (change.recordKind !== "project-file") {
+      throw new Error(
+        `Staged project file ${change.recordId} matched a ${change.recordKind} change.`
+      );
+    }
+    if (!isObjectRecord2(change.nextData)) {
+      throw new Error(
+        `Staged project file ${change.recordId} has no local source record.`
+      );
+    }
+    const completed = {
+      ...change,
+      nextData: {
+        ...change.nextData,
+        id: change.recordId,
+        projectId: args.projectId,
+        status: "uploaded",
+        storageKey: `local-candidate/${change.recordId}`,
+        storageETag: "local-candidate"
+      }
+    };
+    return completed;
+  });
+}
 function transportChangesForStatus(status) {
   return status.changes.map((change) => ({
     recordKind: change.recordKind,
@@ -102478,7 +102673,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.9",
-      cliVersion: "0.26.2",
+      cliVersion: "0.26.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -103792,6 +103987,7 @@ import {
   resolve as resolve3,
   sep as sep5
 } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -103875,9 +104071,46 @@ function stableTestValue(value) {
 function display(value) {
   return stableTestValue(value);
 }
-function assertMatcher(condition, expectationValue, message, expected, received = expectationValue.actual) {
-  if (condition === expectationValue.negated)
-    throw new NeoTestAssertionError(message, expected, received);
+function matcherFailureMessage(kind, expectationValue, expected, received, details) {
+  const actual = expectationValue.actual;
+  const negation = expectationValue.negated ? "not " : "";
+  switch (kind) {
+    case "toBe":
+      return `Expected ${display(actual)} ${negation}to be ${display(expected)}.`;
+    case "toEqual":
+      return `Expected ${display(actual)} ${negation}to equal ${display(expected)}.`;
+    case "toBeNull":
+      return `Expected ${display(actual)} ${negation}to be null.`;
+    case "boolean":
+      return `Expected ${display(actual)} ${negation}to be ${String(expected)}.`;
+    case "numeric":
+      return `Expected ${display(actual)} ${negation}to satisfy numeric comparison with ${display(expected)}.`;
+    case "toContain":
+      return `Expected ${display(actual)} ${negation}to contain ${display(expected)}.`;
+    case "toHaveLength":
+      return `Expected length ${String(expected)}, received ${String(received)}.`;
+    case "toMatchObject":
+      return `Expected ${display(actual)} ${negation}to match ${display(expected)}.`;
+    case "toThrow":
+      return `Expected callback ${negation}to throw${details === void 0 ? "" : ` a message containing ${display(details)}`}.`;
+    case "mock":
+      return `Expected mock ${negation}to match recorded calls ${display(details)}.`;
+  }
+}
+function assertMatcher(condition, expectationValue, messageKind, expected, received = expectationValue.actual, details) {
+  if (condition === expectationValue.negated) {
+    throw new NeoTestAssertionError(
+      matcherFailureMessage(
+        messageKind,
+        expectationValue,
+        expected,
+        received,
+        details
+      ),
+      expected,
+      received
+    );
+  }
 }
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
@@ -104426,8 +104659,7 @@ function mockResponse(environment, mock, selected2, call) {
   };
 }
 function partialObjectMatch(actual, expected) {
-  if (!isRecord10(expected))
-    return stableTestValue(actual) === stableTestValue(expected);
+  if (!isRecord10(expected)) return isDeepStrictEqual(actual, expected);
   if (!isRecord10(actual)) return false;
   return Object.entries(expected).every(
     ([key, value]) => partialObjectMatch(actual[key], value)
@@ -104584,56 +104816,28 @@ function interceptTestCallCore(environment, call) {
     }
     return { handled: true, value: null };
   }
-  const matcherIds = /* @__PURE__ */ new Set([
-    NEO_TEST_IDS.toBe,
-    NEO_TEST_IDS.toEqual,
-    NEO_TEST_IDS.toBeNull,
-    NEO_TEST_IDS.toBeTrue,
-    NEO_TEST_IDS.toBeFalse,
-    NEO_TEST_IDS.toBeGreaterThan,
-    NEO_TEST_IDS.toBeGreaterThanOrEqual,
-    NEO_TEST_IDS.toBeLessThan,
-    NEO_TEST_IDS.toBeLessThanOrEqual,
-    NEO_TEST_IDS.toContain,
-    NEO_TEST_IDS.toHaveLength,
-    NEO_TEST_IDS.toMatchObject,
-    NEO_TEST_IDS.toThrow,
-    NEO_TEST_IDS.toHaveBeenCalled,
-    NEO_TEST_IDS.toHaveBeenCalledTimes,
-    NEO_TEST_IDS.toHaveBeenCalledWith
-  ]);
-  if (!matcherIds.has(call.memberId)) return { handled: false };
+  if (!MATCHER_IDS.has(call.memberId)) return { handled: false };
   const expectationValue = readExpectation(call.receiver);
   const actual = expectationValue.actual;
   if (call.memberId === NEO_TEST_IDS.toBe) {
     assertMatcher(
       Object.is(actual, call.args[0]),
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to be ${display(call.args[0])}.`,
+      "toBe",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toEqual) {
     assertMatcher(
-      stableTestValue(actual) === stableTestValue(call.args[0]),
+      isDeepStrictEqual(actual, call.args[0]),
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to equal ${display(call.args[0])}.`,
+      "toEqual",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toBeNull) {
-    assertMatcher(
-      actual === null,
-      expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to be null.`,
-      null
-    );
+    assertMatcher(actual === null, expectationValue, "toBeNull", null);
   } else if (call.memberId === NEO_TEST_IDS.toBeTrue || call.memberId === NEO_TEST_IDS.toBeFalse) {
     const expected = call.memberId === NEO_TEST_IDS.toBeTrue;
-    assertMatcher(
-      actual === expected,
-      expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to be ${String(expected)}.`,
-      expected
-    );
+    assertMatcher(actual === expected, expectationValue, "boolean", expected);
   } else if (call.memberId === NEO_TEST_IDS.toBeGreaterThan || call.memberId === NEO_TEST_IDS.toBeGreaterThanOrEqual || call.memberId === NEO_TEST_IDS.toBeLessThan || call.memberId === NEO_TEST_IDS.toBeLessThanOrEqual) {
     const left = Number(actual);
     const right = Number(call.args[0]);
@@ -104641,25 +104845,18 @@ function interceptTestCallCore(environment, call) {
     assertMatcher(
       Number.isFinite(left) && Number.isFinite(right) && matches,
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to satisfy numeric comparison with ${display(call.args[0])}.`,
+      "numeric",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toContain) {
-    const contains2 = typeof actual === "string" ? actual.includes(String(call.args[0])) : Array.isArray(actual) && actual.some(
-      (entry) => stableTestValue(entry) === stableTestValue(call.args[0])
-    );
-    assertMatcher(
-      contains2,
-      expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to contain ${display(call.args[0])}.`,
-      call.args[0]
-    );
+    const contains2 = typeof actual === "string" ? actual.includes(String(call.args[0])) : Array.isArray(actual) && actual.some((entry) => isDeepStrictEqual(entry, call.args[0]));
+    assertMatcher(contains2, expectationValue, "toContain", call.args[0]);
   } else if (call.memberId === NEO_TEST_IDS.toHaveLength) {
     const length = typeof actual === "string" || Array.isArray(actual) ? actual.length : isRecord10(actual) ? Object.keys(actual).length : -1;
     assertMatcher(
       length === call.args[0],
       expectationValue,
-      `Expected length ${String(call.args[0])}, received ${String(length)}.`,
+      "toHaveLength",
       call.args[0],
       length
     );
@@ -104667,7 +104864,7 @@ function interceptTestCallCore(environment, call) {
     assertMatcher(
       partialObjectMatch(actual, call.args[0]),
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to match ${display(call.args[0])}.`,
+      "toMatchObject",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toThrow) {
@@ -104683,9 +104880,10 @@ function interceptTestCallCore(environment, call) {
     assertMatcher(
       matches,
       expectationValue,
-      `Expected callback ${expectationValue.negated ? "not " : ""}to throw${pattern === void 0 ? "" : ` a message containing ${display(pattern)}`}.`,
+      "toThrow",
       pattern ?? "a catchable NeoScript error",
-      thrown === void 0 ? "no throw" : errorMessage2(thrown)
+      thrown === void 0 ? "no throw" : errorMessage2(thrown),
+      pattern
     );
   } else {
     const handle = readMockHandle(actual);
@@ -104695,15 +104893,14 @@ function interceptTestCallCore(environment, call) {
         "Expected value is not an active mock handle."
       );
     }
-    const matches = call.memberId === NEO_TEST_IDS.toHaveBeenCalled ? mock.calls.length > 0 : call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length === call.args[0] : mock.calls.some(
-      (args) => stableTestValue(args) === stableTestValue(call.args)
-    );
+    const matches = call.memberId === NEO_TEST_IDS.toHaveBeenCalled ? mock.calls.length > 0 : call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length === call.args[0] : mock.calls.some((args) => isDeepStrictEqual(args, call.args));
     assertMatcher(
       matches,
       expectationValue,
-      `Expected mock ${expectationValue.negated ? "not " : ""}to match recorded calls ${display(mock.calls)}.`,
+      "mock",
       call.memberId === NEO_TEST_IDS.toHaveBeenCalled ? "at least one call" : call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? call.args[0] : call.args,
-      call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length : mock.calls
+      call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length : mock.calls,
+      mock.calls
     );
   }
   return { handled: true, value: null };
@@ -104994,8 +105191,24 @@ function maintainNeoTestBuildCache(root, maxBytes = TEST_BUILD_CACHE_LIMIT_BYTES
   }
 }
 function formatTestDuration(durationMs) {
+  if (durationMs >= 1e3) {
+    const seconds = durationMs / 1e3;
+    return `${seconds < 10 ? seconds.toFixed(2) : seconds.toFixed(1)}s`;
+  }
   return `${durationMs < 10 ? durationMs.toFixed(2) : durationMs.toFixed(1)}ms`;
 }
+function paintTestDuration(durationMs) {
+  const formatted = formatTestDuration(durationMs);
+  return durationMs >= 300 ? color.yellow(formatted) : color.dim(formatted);
+}
+function formatStatusCounts(passed, failed, total, skipped = 0) {
+  const parts = [
+    failed > 0 ? color.red(`${failed} failed`) : null,
+    passed > 0 ? color.green(`${passed} passed`) : null,
+    skipped > 0 ? color.yellow(`${skipped} skipped`) : null
+  ].filter((part) => part !== null);
+  return `${parts.join(color.dim(" | "))} ${color.dim(`(${total})`)}`;
+}
 async function runTest(workspace, options, dependencies = {}) {
   const started = Date.now();
   const performanceStarted = performance.now();
@@ -105025,7 +105238,29 @@ async function runTest(workspace, options, dependencies = {}) {
     }
   };
   process.on("SIGINT", handleSigint);
+  const phaseDurations = {
+    prepare: 0,
+    select: 0,
+    compile: 0,
+    register: 0,
+    execute: 0,
+    finalize: 0
+  };
   let phase = "prepare";
+  let phaseStarted = performanceStarted;
+  const enterPhase = (next, label) => {
+    const finished = performance.now();
+    phaseDurations[phase] += finished - phaseStarted;
+    phase = next;
+    phaseStarted = finished;
+    dependencies.progress?.update(label);
+  };
+  const finishPhase = () => {
+    const finished = performance.now();
+    phaseDurations[phase] += finished - phaseStarted;
+    phaseStarted = finished;
+  };
+  dependencies.progress?.update("Preparing test project\u2026");
   try {
     let candidate = dependencies.prepareLocalCandidate === void 0 ? preparedHookCandidate(workspace) : null;
     let candidateInputFingerprint = null;
@@ -105037,7 +105272,11 @@ async function runTest(workspace, options, dependencies = {}) {
         candidate = cachedTestCandidate(workspace, candidateInputFingerprint);
       }
       if (candidate === null) {
-        const prepared = dependencies.prepareLocalCandidate === void 0 ? await prepareLocalCandidateV4(workspace) : await dependencies.prepareLocalCandidate(workspace);
+        const prepared = dependencies.prepareLocalCandidate === void 0 ? await prepareLocalCandidateV4(workspace, {
+          onPhase: (label) => {
+            dependencies.progress?.update(label);
+          }
+        }) : await dependencies.prepareLocalCandidate(workspace);
         if (prepared.document === null) {
           throw new NeoTestReportWriteError(
             "Local test preparation did not produce a project document."
@@ -105069,7 +105308,7 @@ async function runTest(workspace, options, dependencies = {}) {
       rawDocument,
       candidate.documentSha256
     );
-    phase = "select";
+    enterPhase("select", "Selecting test files\u2026");
     let selectedPaths;
     try {
       selectedPaths = selectedSpecPaths(workspace, options.selectors);
@@ -105084,7 +105323,7 @@ async function runTest(workspace, options, dependencies = {}) {
         "No .spec.neo files matched. Pass --passWithNoTests to treat this as success."
       );
     }
-    phase = "compile";
+    enterPhase("compile", "Compiling test files\u2026");
     specs = selectedPaths.map(
       (path) => compileSpec(workspace, rawDocument, path, compilationHash)
     );
@@ -105098,7 +105337,7 @@ async function runTest(workspace, options, dependencies = {}) {
         );
       }
     }
-    phase = "register";
+    enterPhase("register", "Registering tests\u2026");
     const registered = specs.map((spec) => registerSpec(spec, rawDocument));
     const selectedTests = registered.flatMap((entry) => entry.tests).filter((test) => pattern === null || pattern.test(test.fullName));
     for (const entry of registered) {
@@ -105115,7 +105354,7 @@ async function runTest(workspace, options, dependencies = {}) {
       );
     }
     const selectedIds = new Set(selectedTests.map((test) => test.id));
-    phase = "execute";
+    enterPhase("execute", "Running tests\u2026");
     const timeoutMs = options.timeoutMs ?? workspace.config.test?.timeoutMs ?? 5e3;
     for (const entry of registered) {
       const executed = await executeRegisteredSpec(
@@ -105133,6 +105372,7 @@ async function runTest(workspace, options, dependencies = {}) {
     if (results.some((result) => result.status === "failed") || [...fileFailuresByPath.values()].some((failures) => failures.length > 0)) {
       exitCode = 1;
     }
+    enterPhase("finalize", "Finalizing test report\u2026");
     const buildManifest = {
       version: 1,
       cliVersion: PROJECT_SCHEMA_CONTRACT.cliVersion,
@@ -105168,6 +105408,8 @@ async function runTest(workspace, options, dependencies = {}) {
       related: []
     });
   }
+  finishPhase();
+  dependencies.progress?.stop();
   process.off("SIGINT", handleSigint);
   const failed = results.filter((result) => result.status === "failed").length;
   const selectedTestTotal = [...selectedTestCountByFile.values()].reduce(
@@ -105221,6 +105463,14 @@ async function runTest(workspace, options, dependencies = {}) {
       sharedStartupDurationMs,
       testDurationMs
     },
+    timings: {
+      prepareMs: phaseDurations.prepare,
+      selectMs: phaseDurations.select,
+      compileMs: phaseDurations.compile,
+      registerMs: phaseDurations.register,
+      executeMs: phaseDurations.execute,
+      finalizeMs: phaseDurations.finalize
+    },
     testFiles,
     diagnostics,
     startedAt
@@ -105244,33 +105494,63 @@ async function runTest(workspace, options, dependencies = {}) {
   if (options.reporter === "json") {
     if (options.outputFile === null) process.stdout.write(serialized);
   } else {
+    console.log("");
     console.log(
-      `\u21BB shared startup (${formatTestDuration(report.summary.sharedStartupDurationMs)})`
+      ` ${color.bold("RUN")} ${color.dim(`neo ${PROJECT_SCHEMA_CONTRACT.cliVersion} ${workspace.root}`)}`
     );
-    for (const result of results) {
+    console.log("");
+    console.log(
+      ` ${color.cyan("\u21BB")} ${color.dim("shared startup")} ${paintTestDuration(report.summary.sharedStartupDurationMs)}`
+    );
+    for (const file of testFiles) {
+      const fileDurationMs = file.tests.reduce(
+        (sum, test) => sum + test.durationMs,
+        0
+      );
+      const fileSymbol = file.status === "passed" ? color.green("\u2713") : file.status === "failed" ? color.red("\xD7") : color.yellow("!");
+      const testLabel = `${file.tests.length} ${file.tests.length === 1 ? "test" : "tests"}`;
       console.log(
-        `${result.status === "passed" ? "\u2713" : "\u2717"} ${result.file} > ${result.name} (total ${formatTestDuration(result.durationMs)}; test ${formatTestDuration(result.testDurationMs)}; startup ${formatTestDuration(result.startupDurationMs)})`
+        ` ${fileSymbol} ${color.bold(file.path)} ${color.dim(`(${testLabel})`)} ${paintTestDuration(fileDurationMs)}`
       );
-      for (const failure of result.failures)
-        console.log(`  ${failure.message}`);
-    }
-    for (const file of testFiles) {
+      for (const result of file.tests) {
+        const resultSymbol = result.status === "passed" ? color.green("\u2713") : color.red("\xD7");
+        console.log(
+          `   ${resultSymbol} ${result.name}  ${color.dim("total")} ${paintTestDuration(result.durationMs)} ${color.dim(`(test ${formatTestDuration(result.testDurationMs)}, startup ${formatTestDuration(result.startupDurationMs)})`)}`
+        );
+        for (const failure of result.failures) {
+          console.log(`     ${color.red(failure.message)}`);
+        }
+      }
       if (file.status === "interrupted") {
         console.log(
-          `! ${file.path} > interrupted before all selected tests ran`
+          `   ${color.yellow("!")} interrupted before all selected tests ran`
         );
       }
       for (const failure of file.failures) {
         console.log(
-          `\u2717 ${file.path} > ${failure.frames[0]?.member ?? "suite hook"}`
+          `   ${color.red("\xD7")} ${failure.frames[0]?.member ?? "suite hook"}`
         );
-        console.log(`  ${failure.message}`);
+        console.log(`     ${color.red(failure.message)}`);
       }
     }
-    for (const diagnostic of diagnostics)
-      console.log(`\u2717 ${diagnostic.message}`);
+    for (const diagnostic of diagnostics) {
+      console.log(` ${color.red("\xD7")} ${diagnostic.message}`);
+    }
+    console.log("");
+    const passedFiles = testFiles.filter(
+      (file) => file.status === "passed"
+    ).length;
+    const failedFiles = testFiles.filter(
+      (file) => file.status === "failed"
+    ).length;
+    console.log(
+      ` ${color.bold(pad("Test Files", 11))} ${formatStatusCounts(passedFiles, failedFiles, report.summary.files)}`
+    );
     console.log(
-      `${report.summary.passed} passed, ${report.summary.failed} failed (total ${formatTestDuration(report.summary.durationMs)}; test ${formatTestDuration(report.summary.testDurationMs)}; startup ${formatTestDuration(report.summary.startupDurationMs)})`
+      ` ${color.bold(pad("Tests", 11))} ${formatStatusCounts(report.summary.passed, report.summary.failed, report.summary.tests, report.summary.skipped)}`
+    );
+    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)})`)}`
     );
   }
   if (!report.success) process.exitCode = exitCode;
@@ -105317,7 +105597,7 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
     errors
   };
 }
-var TEST_BUILD_CACHE_LIMIT_BYTES, ABANDONED_TEMP_MAX_AGE_MS, TEST_CANDIDATE_CACHE_REVISION, NeoTestUsageError, NeoTestNoTestsError, NeoTestRegistrationError, NeoTestReportWriteError, NeoTestPreparedCandidateError, NeoTestInterruptedError, NeoTestAssertionError, ERROR_SOURCE_POSITIONS, SHARED_EVALUATOR_BASES, REGISTRATION_IDS;
+var TEST_BUILD_CACHE_LIMIT_BYTES, ABANDONED_TEMP_MAX_AGE_MS, TEST_CANDIDATE_CACHE_REVISION, NeoTestUsageError, NeoTestNoTestsError, NeoTestRegistrationError, NeoTestReportWriteError, NeoTestPreparedCandidateError, NeoTestInterruptedError, NeoTestAssertionError, ERROR_SOURCE_POSITIONS, SHARED_EVALUATOR_BASES, REGISTRATION_IDS, MATCHER_IDS;
 var init_test = __esm({
   "src/commands/test.ts"() {
     "use strict";
@@ -105330,6 +105610,7 @@ var init_test = __esm({
     init_push();
     init_registry2();
     init_push_hook();
+    init_ui();
     TEST_BUILD_CACHE_LIMIT_BYTES = 512 * 1024 * 1024;
     ABANDONED_TEMP_MAX_AGE_MS = 60 * 60 * 1e3;
     TEST_CANDIDATE_CACHE_REVISION = 1;
@@ -105374,6 +105655,24 @@ var init_test = __esm({
       NEO_TEST_IDS.beforeEach,
       NEO_TEST_IDS.afterEach
     ]);
+    MATCHER_IDS = /* @__PURE__ */ new Set([
+      NEO_TEST_IDS.toBe,
+      NEO_TEST_IDS.toEqual,
+      NEO_TEST_IDS.toBeNull,
+      NEO_TEST_IDS.toBeTrue,
+      NEO_TEST_IDS.toBeFalse,
+      NEO_TEST_IDS.toBeGreaterThan,
+      NEO_TEST_IDS.toBeGreaterThanOrEqual,
+      NEO_TEST_IDS.toBeLessThan,
+      NEO_TEST_IDS.toBeLessThanOrEqual,
+      NEO_TEST_IDS.toContain,
+      NEO_TEST_IDS.toHaveLength,
+      NEO_TEST_IDS.toMatchObject,
+      NEO_TEST_IDS.toThrow,
+      NEO_TEST_IDS.toHaveBeenCalled,
+      NEO_TEST_IDS.toHaveBeenCalledTimes,
+      NEO_TEST_IDS.toHaveBeenCalledWith
+    ]);
   }
 });
 
@@ -108939,7 +109238,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.26.2");
+    console.log("0.26.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -109223,15 +109522,25 @@ async function main() {
           "--testTimeout must be a positive number of milliseconds."
         );
       }
-      const { runTest: runTest2 } = await Promise.resolve().then(() => (init_test(), test_exports));
-      await runTest2(workspace, {
-        selectors: args.positional,
-        testNamePattern: stringFlag(args, "testNamePattern"),
-        reporter: reporterValue,
-        outputFile: stringFlag(args, "outputFile") ?? stringFlag(args, "output-file"),
-        passWithNoTests: boolFlag(args, "passWithNoTests"),
-        ...timeoutMs === void 0 ? {} : { timeoutMs }
-      });
+      const progress = reporterValue === "default" && process.stdout.isTTY === true ? spinner("Preparing test project\u2026") : null;
+      try {
+        const { runTest: runTest2 } = await Promise.resolve().then(() => (init_test(), test_exports));
+        await runTest2(
+          workspace,
+          {
+            selectors: args.positional,
+            testNamePattern: stringFlag(args, "testNamePattern"),
+            reporter: reporterValue,
+            outputFile: stringFlag(args, "outputFile") ?? stringFlag(args, "output-file"),
+            passWithNoTests: boolFlag(args, "passWithNoTests"),
+            ...timeoutMs === void 0 ? {} : { timeoutMs }
+          },
+          progress === null ? {} : { progress }
+        );
+      } catch (error) {
+        progress?.fail("Test run failed.");
+        throw error;
+      }
       return;
     }
     case "dev": {

package/package.json

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