@quenty/nevermore-cli 4.38.0 → 4.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/nevermore-cli",
-  "version": "4.38.0",
+  "version": "4.40.0",
   "description": "CLI interface for Nevermore",
   "type": "module",
   "keywords": [
@@ -57,5 +57,5 @@
   "engines": {
     "node": ">=16"
   },
-  "gitHead": "7d1c8f4960e49256679a62bdc6aec0d51b7d0d89"
+  "gitHead": "2c903e91ae2ea1702ae1ce94af20af83af81e4fe"
 }

package/src/commands/batch-command/batch-deploy-command.ts

@@ -236,13 +236,17 @@ async function _runAsync(args: BatchDeployArgs): Promise<void> {
 
         const injected = await injectDeployMetadataAsync(
           builtPlace,
-          buildDeployMetadataAttributes(deployGitInfo, {
-            target: targetName,
-            published: publish,
-            timestamp: deployTimestamp,
-            universeId: buildTarget.target.universeId,
-            placeId: buildTarget.target.placeId,
-          })
+          buildDeployMetadataAttributes(
+            deployGitInfo,
+            {
+              target: targetName,
+              published: publish,
+              timestamp: deployTimestamp,
+              universeId: buildTarget.target.universeId,
+              placeId: buildTarget.target.placeId,
+            },
+            buildTarget.manifestPlaces
+          )
         );
 
         let version: number;

package/src/commands/deploy-command/index.ts

@@ -34,6 +34,7 @@ import {
   loadDeployConfigAsync,
   resolveDeployConfigPath,
   resolveDeployTargetPlaces,
+  toManifestPlaceInfo,
 } from '../../utils/build/deploy-config.js';
 import { handleInitAsync } from './deploy-init.js';
 import {
@@ -256,6 +257,7 @@ export class DeployCommand<T> implements CommandModule<T, DeployArgs> {
 
     const config = await loadDeployConfigAsync(resolveDeployConfigPath(cwd));
     const places = resolveDeployTargetPlaces(config, targetName);
+    const manifestPlaces = places.map(toManifestPlaceInfo);
     const isMultiPlace = places.length > 1;
 
     if (isMultiPlace) {
@@ -279,6 +281,7 @@ export class DeployCommand<T> implements CommandModule<T, DeployArgs> {
             packageName,
             path: cwd,
             target: place,
+            manifestPlaces,
           };
         })
       : [
@@ -287,6 +290,7 @@ export class DeployCommand<T> implements CommandModule<T, DeployArgs> {
             packageName,
             path: cwd,
             target: places[0]!,
+            manifestPlaces,
           },
         ];
 
@@ -402,13 +406,17 @@ export class DeployCommand<T> implements CommandModule<T, DeployArgs> {
 
           const injected = await injectDeployMetadataAsync(
             builtPlace,
-            buildDeployMetadataAttributes(deployGitInfo, {
-              target: targetName,
-              published: publish,
-              timestamp: deployTimestamp,
-              universeId: args.universeId ?? buildTarget.target.universeId,
-              placeId: args.placeId ?? buildTarget.target.placeId,
-            })
+            buildDeployMetadataAttributes(
+              deployGitInfo,
+              {
+                target: targetName,
+                published: publish,
+                timestamp: deployTimestamp,
+                universeId: args.universeId ?? buildTarget.target.universeId,
+                placeId: args.placeId ?? buildTarget.target.placeId,
+              },
+              buildTarget.manifestPlaces
+            )
           );
 
           let uploadResult: Awaited<ReturnType<typeof uploadPlaceAsync>>;

package/src/commands/tools-command/strip-sourcemap-jest-command.ts

@@ -10,13 +10,17 @@ interface StripSourcemapJestArgs extends NevermoreGlobalArgs {
 }
 
 /**
- * Temporary workaround: remove Jest nodes from sourcemap.json.
+ * Temporary workaround: strip shadowing modules from Jest subtrees in sourcemap.json.
  *
  * luau-lsp's require-by-name resolution picks the first file matching a name
  * in the sourcemap. Jest vendors internal copies of modules (Promise, string,
  * symbol, etc.) that shadow Nevermore packages. The real loader handles this
  * correctly, but luau-lsp doesn't yet.
  *
+ * We drop only the Jest descendants whose name also exists elsewhere in the
+ * sourcemap (the shadowing copies), and keep the Jest-unique modules (Jest,
+ * JestGlobals, ...) so `require("Jest")` still resolves.
+ *
  * Long-term fix: smarter require resolution in luau-lsp (plugins or fork).
  */
 export const stripSourcemapJestCommand: CommandModule<
@@ -25,7 +29,7 @@ export const stripSourcemapJestCommand: CommandModule<
 > = {
   command: 'strip-sourcemap-jest',
   describe:
-    'Remove Jest nodes from sourcemap.json to avoid luau-lsp name conflicts',
+    "Strip modules from Jest subtrees in sourcemap.json that shadow names elsewhere, keeping require('Jest') resolvable",
   builder: (yargs) => {
     return yargs.option('sourcemap', {
       describe: 'Path to sourcemap.json',
@@ -46,31 +50,57 @@ export const stripSourcemapJestCommand: CommandModule<
 
     const sourcemap = JSON.parse(content) as SourcemapNode;
 
-    let removed = 0;
+    // Every module name that lives OUTSIDE any Jest subtree. Jest's vendored copies of these
+    // are what shadow the real Nevermore modules under luau-lsp's first-match resolution.
+    const externalNames = new Set<string>();
+    function collectExternalNames(
+      node: SourcemapNode,
+      insideJest: boolean
+    ): void {
+      if (!node.children) return;
+      for (const child of node.children) {
+        const childInsideJest = insideJest || child.name === 'Jest';
+        if (!childInsideJest) {
+          externalNames.add(child.name);
+        }
+        collectExternalNames(child, childInsideJest);
+      }
+    }
+    collectExternalNames(sourcemap, false);
 
-    function removeJestNodes(node: SourcemapNode): void {
+    // Within each Jest subtree, drop any node whose name also exists elsewhere (the shadowing
+    // copies), keeping the Jest-unique modules so require("Jest") still resolves. Also drop a
+    // Jest node nested inside another Jest: the jest-lua package folder ("Jest", whose
+    // init.lua exports `.Globals`) contains a leaf "Jest" submodule that lacks `.Globals`, and
+    // the duplicate name makes require("Jest") resolve to the wrong one for some packages.
+    let stripped = 0;
+    function stripShadowingNodes(
+      node: SourcemapNode,
+      insideJest: boolean
+    ): void {
       if (!node.children) return;
 
-      node.children = node.children.filter((child) => {
-        if (child.name === 'Jest') {
-          removed++;
-          return false;
-        }
-        return true;
-      });
+      if (insideJest) {
+        node.children = node.children.filter((child) => {
+          if (externalNames.has(child.name) || child.name === 'Jest') {
+            stripped++;
+            return false;
+          }
+          return true;
+        });
+      }
 
       for (const child of node.children) {
-        removeJestNodes(child);
+        stripShadowingNodes(child, insideJest || child.name === 'Jest');
       }
     }
-
-    removeJestNodes(sourcemap);
+    stripShadowingNodes(sourcemap, false);
 
     fs.writeFileSync(sourcemapPath, JSON.stringify(sourcemap));
 
-    if (removed > 0) {
+    if (stripped > 0) {
       OutputHelper.info(
-        `Removed ${removed} Jest node(s) from ${sourcemapPath}`
+        `Stripped ${stripped} shadowing node(s) from Jest subtrees in ${sourcemapPath}`
       );
     }
   },

package/src/utils/batch/changed-packages-utils.ts

@@ -3,9 +3,11 @@ import { execa } from 'execa';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import {
   DeployTarget,
+  ManifestPlaceInfo,
   loadDeployConfigAsync,
   resolveDeployConfigPath,
   resolveDeployTargetPlaces,
+  toManifestPlaceInfo,
 } from '../build/deploy-config.js';
 
 export interface TargetPackage {
@@ -33,6 +35,13 @@ export interface BatchTarget {
   path: string;
   /** The single resolved place this BatchTarget represents. */
   target: DeployTarget;
+  /**
+   * Every place of this package's target (including `target` itself), stamped
+   * into the runtime manifest so a deployed place can resolve its siblings' IDs.
+   * Same for every BatchTarget fanned out from one package. Only the deploy
+   * paths populate this; test/script BatchTargets omit it.
+   */
+  manifestPlaces?: ManifestPlaceInfo[];
 }
 
 /**
@@ -119,19 +128,27 @@ export function flattenToBatchTargets(
 ): BatchTarget[] {
   const result: BatchTarget[] = [];
   for (const pkg of packages) {
+    const manifestPlaces = pkg.activeTargets.map(toManifestPlaceInfo);
     if (pkg.activeTargets.length === 1) {
       result.push({
         name: pkg.name,
         packageName: pkg.name,
         path: pkg.path,
         target: pkg.activeTargets[0]!,
+        manifestPlaces,
       });
       continue;
     }
     for (const target of pkg.activeTargets) {
       const suffix = target.name;
       const name = suffix ? `${pkg.name} - ${suffix}` : pkg.name;
-      result.push({ name, packageName: pkg.name, path: pkg.path, target });
+      result.push({
+        name,
+        packageName: pkg.name,
+        path: pkg.path,
+        target,
+        manifestPlaces,
+      });
     }
   }
   return result;

package/src/utils/build/deploy-config.ts

@@ -36,6 +36,28 @@ export interface DeployConfig {
   targets: Record<string, DeployTargetConfig>;
 }
 
+/**
+ * The subset of a resolved place that gets baked into the runtime manifest
+ * (see the nevermore-cli-manifest package). A deployed place carries the whole
+ * target's place table so it can resolve its siblings' IDs at runtime — e.g. a
+ * chapter place teleporting to another chapter without hard-coding place IDs.
+ */
+export interface ManifestPlaceInfo {
+  /** Place name from a multi-place target (e.g. "chapter0"); absent for single-place targets. */
+  name?: string;
+  placeId: number;
+  universeId: number;
+}
+
+/** Project a resolved deploy place down to the fields stamped into the manifest. */
+export function toManifestPlaceInfo(place: DeployTarget): ManifestPlaceInfo {
+  return {
+    name: place.name,
+    placeId: place.placeId,
+    universeId: place.universeId,
+  };
+}
+
 function _isMultiPlace(
   target: DeployTargetConfig
 ): target is MultiPlaceTargetConfig {

package/src/utils/deploy/deploy-metadata.test.ts

@@ -84,6 +84,34 @@ describe('buildDeployMetadataAttributes', () => {
     );
     expect(attributes.Published).toBe(false);
   });
+
+  it('omits Places when no place table is given', () => {
+    const attributes = buildDeployMetadataAttributes({}, PLACE);
+    expect('Places' in attributes).toBe(false);
+  });
+
+  it('stamps Places as a JSON string preserving large IDs exactly', () => {
+    const attributes = buildDeployMetadataAttributes({}, PLACE, [
+      { name: 'chapter0', placeId: 97235312452456, universeId: 10192566764 },
+      { name: 'chapter1', placeId: 87639818897831, universeId: 10192566764 },
+    ]);
+    expect(typeof attributes.Places).toBe('string');
+    const parsed = JSON.parse(attributes.Places as string);
+    // Large place IDs must survive exactly (JSON text, not a float32 attribute).
+    expect(parsed).toEqual([
+      { name: 'chapter0', placeId: 97235312452456, universeId: 10192566764 },
+      { name: 'chapter1', placeId: 87639818897831, universeId: 10192566764 },
+    ]);
+  });
+
+  it('omits the name key for a single-place (nameless) target', () => {
+    const attributes = buildDeployMetadataAttributes({}, PLACE, [
+      { placeId: 123, universeId: 456 },
+    ]);
+    const parsed = JSON.parse(attributes.Places as string);
+    expect(parsed).toEqual([{ placeId: 123, universeId: 456 }]);
+    expect('name' in parsed[0]).toBe(false);
+  });
 });
 
 describe('packageUsesManifestAsync', () => {

package/src/utils/deploy/deploy-metadata.ts

@@ -7,6 +7,7 @@ import {
 } from '@quenty/nevermore-template-helpers';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import { type BuiltPlace } from '../build/build.js';
+import { type ManifestPlaceInfo } from '../build/deploy-config.js';
 
 /** npm name of the package that ships the manifest module. */
 export const MANIFEST_PACKAGE_NAME = '@quenty/nevermoreclimanifest';
@@ -85,10 +86,16 @@ export interface DeployPlaceInfo {
  * round-trip through Lune serialization as float32, which silently corrupts IDs
  * above 2^24 (e.g. 123456789 -> 123456792). Strings are exact; the Luau reader
  * converts them back with `tonumber`.
+ *
+ * When `places` is given (the whole target's place table), it is stamped as a
+ * `Places` JSON-string attribute. The IDs inside stay numeric — a JSON string
+ * is exact text, and the Luau reader decodes it to 64-bit numbers, so the
+ * float32 hazard that forces the top-level IDs to be stringified doesn't apply.
  */
 export function buildDeployMetadataAttributes(
   git: GitDeployInfo,
-  place: DeployPlaceInfo
+  place: DeployPlaceInfo,
+  places?: readonly ManifestPlaceInfo[]
 ): DeployMetadataAttributes {
   const attributes: DeployMetadataAttributes = {
     Deployed: true,
@@ -101,6 +108,15 @@ export function buildDeployMetadataAttributes(
   if (git.commit) attributes.Commit = git.commit;
   if (git.version) attributes.Version = git.version;
   if (git.branch) attributes.Branch = git.branch;
+  if (places && places.length > 0) {
+    attributes.Places = JSON.stringify(
+      places.map((p) => ({
+        name: p.name,
+        placeId: p.placeId,
+        universeId: p.universeId,
+      }))
+    );
+  }
   return attributes;
 }