@quenty/nevermore-cli 4.35.0 → 4.36.0

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

@@ -0,0 +1,128 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  buildDeployMetadataAttributes,
+  packageUsesManifestAsync,
+  type GitDeployInfo,
+  type DeployPlaceInfo,
+} from './deploy-metadata.js';
+
+async function withPackageJsonAsync(
+  contents: unknown,
+  fn: (dir: string) => Promise<void>
+): Promise<void> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'manifest-gate-'));
+  try {
+    if (contents !== undefined) {
+      await fs.writeFile(
+        path.join(dir, 'package.json'),
+        JSON.stringify(contents)
+      );
+    }
+    await fn(dir);
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+const PLACE: DeployPlaceInfo = {
+  target: 'integration',
+  published: true,
+  timestamp: '2026-07-15T00:00:00.000Z',
+  placeId: 123,
+  universeId: 456,
+};
+
+describe('buildDeployMetadataAttributes', () => {
+  it('always marks the build as deployed and includes place info', () => {
+    const attributes = buildDeployMetadataAttributes({}, PLACE);
+    expect(attributes.Deployed).toBe(true);
+    expect(attributes.Target).toBe('integration');
+    expect(attributes.Published).toBe(true);
+    expect(attributes.Timestamp).toBe('2026-07-15T00:00:00.000Z');
+  });
+
+  it('stringifies place/universe IDs so Lune float32 does not corrupt them', () => {
+    const attributes = buildDeployMetadataAttributes(
+      {},
+      {
+        ...PLACE,
+        placeId: 123456789,
+        universeId: 987654321,
+      }
+    );
+    // Must be exact strings — as numbers these round to 123456792 / 987654336.
+    expect(attributes.PlaceId).toBe('123456789');
+    expect(attributes.UniverseId).toBe('987654321');
+  });
+
+  it('includes git fields when present', () => {
+    const git: GitDeployInfo = {
+      commit: 'a1b2c3d',
+      version: 'a1b2c3d4e5f6',
+      branch: 'main',
+    };
+    const attributes = buildDeployMetadataAttributes(git, PLACE);
+    expect(attributes.Commit).toBe('a1b2c3d');
+    expect(attributes.Version).toBe('a1b2c3d4e5f6');
+    expect(attributes.Branch).toBe('main');
+  });
+
+  it('omits git fields that are unavailable', () => {
+    const attributes = buildDeployMetadataAttributes({}, PLACE);
+    expect('Commit' in attributes).toBe(false);
+    expect('Version' in attributes).toBe(false);
+    expect('Branch' in attributes).toBe(false);
+  });
+
+  it('reflects a Saved (unpublished) deploy', () => {
+    const attributes = buildDeployMetadataAttributes(
+      {},
+      { ...PLACE, published: false }
+    );
+    expect(attributes.Published).toBe(false);
+  });
+});
+
+describe('packageUsesManifestAsync', () => {
+  it('is true for the manifest package itself', async () => {
+    await withPackageJsonAsync(
+      { name: '@quenty/nevermoreclimanifest' },
+      async (dir) => {
+        expect(await packageUsesManifestAsync(dir)).toBe(true);
+      }
+    );
+  });
+
+  it('is true for a direct dependent', async () => {
+    await withPackageJsonAsync(
+      {
+        name: '@quenty/somepackage',
+        dependencies: { '@quenty/nevermoreclimanifest': 'workspace:*' },
+      },
+      async (dir) => {
+        expect(await packageUsesManifestAsync(dir)).toBe(true);
+      }
+    );
+  });
+
+  it('is false for an unrelated package', async () => {
+    await withPackageJsonAsync(
+      {
+        name: '@quenty/maid',
+        dependencies: { '@quenty/loader': 'workspace:*' },
+      },
+      async (dir) => {
+        expect(await packageUsesManifestAsync(dir)).toBe(false);
+      }
+    );
+  });
+
+  it('is false when there is no package.json', async () => {
+    await withPackageJsonAsync(undefined, async (dir) => {
+      expect(await packageUsesManifestAsync(dir)).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,194 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import {
+  BuildContext,
+  resolvePackagePath,
+} from '@quenty/nevermore-template-helpers';
+import { OutputHelper } from '@quenty/cli-output-helpers';
+import { type BuiltPlace } from '../build/build.js';
+
+/** npm name of the package that ships the manifest module. */
+export const MANIFEST_PACKAGE_NAME = '@quenty/nevermoreclimanifest';
+
+/**
+ * Attribute map written onto the built place's NevermoreCLIManifestUtils module.
+ * Keys are attribute names and MUST match the `ATTRIBUTE` table in
+ * src/nevermore-cli-manifest/src/Shared/NevermoreCLIManifestUtils.lua.
+ */
+export type DeployMetadataAttributes = Record<
+  string,
+  string | number | boolean
+>;
+
+const INJECT_SCRIPT_PATH = resolvePackagePath(
+  import.meta.url,
+  'build-scripts',
+  'transform-inject-deploy-metadata.luau'
+);
+
+function _git(args: string[]): string | undefined {
+  try {
+    return execSync(`git ${args.join(' ')}`, {
+      encoding: 'utf-8',
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return undefined;
+  }
+}
+
+/** Git facts about the working tree the deploy was built from. */
+export interface GitDeployInfo {
+  /** Short commit SHA, e.g. "a1b2c3d". */
+  commit?: string;
+  /** Full commit SHA. */
+  version?: string;
+  /** Current branch name, or undefined in a detached HEAD. */
+  branch?: string;
+}
+
+/**
+ * Collect git metadata once per deploy. Every field is best-effort — a missing
+ * git binary or a non-repo directory yields an empty object rather than an error.
+ */
+export function gatherGitDeployInfo(): GitDeployInfo {
+  const info: GitDeployInfo = {};
+  const commit = _git(['rev-parse', '--short', 'HEAD']);
+  if (commit) info.commit = commit;
+  const version = _git(['rev-parse', 'HEAD']);
+  if (version) info.version = version;
+  const branch = _git(['rev-parse', '--abbrev-ref', 'HEAD']);
+  if (branch && branch !== 'HEAD') info.branch = branch;
+  return info;
+}
+
+/** Per-place facts known at deploy time. */
+export interface DeployPlaceInfo {
+  /** Deploy target name from deploy.nevermore.json (e.g. "test", "integration"). */
+  target: string;
+  /** True when published live (`--publish`); false when only Saved. */
+  published: boolean;
+  /** ISO 8601 timestamp — pass one value for the whole deploy so every place agrees. */
+  timestamp: string;
+  placeId: number;
+  universeId: number;
+}
+
+/**
+ * Build the attribute map injected into the built place. `Deployed` is always
+ * true here — its mere presence is what distinguishes a deployed build from a
+ * Studio session at runtime.
+ *
+ * Place and universe IDs are stringified on purpose: Roblox `number` attributes
+ * 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`.
+ */
+export function buildDeployMetadataAttributes(
+  git: GitDeployInfo,
+  place: DeployPlaceInfo
+): DeployMetadataAttributes {
+  const attributes: DeployMetadataAttributes = {
+    Deployed: true,
+    Target: place.target,
+    Timestamp: place.timestamp,
+    Published: place.published,
+    PlaceId: String(place.placeId),
+    UniverseId: String(place.universeId),
+  };
+  if (git.commit) attributes.Commit = git.commit;
+  if (git.version) attributes.Version = git.version;
+  if (git.branch) attributes.Branch = git.branch;
+  return attributes;
+}
+
+/** A built place with metadata injected, plus a handle to clean up its temp dir. */
+export interface InjectedPlace {
+  builtPlace: BuiltPlace;
+  cleanupAsync(): Promise<void>;
+}
+
+/**
+ * Run the Lune transform that writes `attributes` onto the place's manifest
+ * module. Produces a fresh .rbxl in its own temp directory so a shared rojo
+ * build (multi-place / batch deploys) is never mutated in place. The caller
+ * uploads `result.builtPlace` and then calls `result.cleanupAsync()`.
+ */
+export async function injectDeployMetadataAsync(
+  builtPlace: BuiltPlace,
+  attributes: DeployMetadataAttributes
+): Promise<InjectedPlace> {
+  const context = await BuildContext.createAsync({ prefix: 'deploy-meta-' });
+  const outputPath = context.resolvePath('deploy-metadata.rbxl');
+
+  OutputHelper.verbose('Injecting deploy metadata into built place...');
+  await context.executeLuneTransformScriptAsync(
+    INJECT_SCRIPT_PATH,
+    builtPlace.rbxlPath,
+    outputPath,
+    JSON.stringify(attributes)
+  );
+
+  return {
+    builtPlace: { ...builtPlace, rbxlPath: outputPath },
+    cleanupAsync: () => context.cleanupAsync(),
+  };
+}
+
+/**
+ * Inject `attributes` by rewriting `rbxlPath` in place. Only safe when the
+ * caller owns the file exclusively (e.g. a per-session test build); deploys use
+ * {@link injectDeployMetadataAsync} instead because they can share one rojo
+ * build across multiple places.
+ */
+export async function injectDeployMetadataInPlaceAsync(
+  rbxlPath: string,
+  attributes: DeployMetadataAttributes
+): Promise<void> {
+  const context = await BuildContext.createAsync({ prefix: 'deploy-meta-' });
+  try {
+    OutputHelper.verbose('Injecting deploy metadata into test build...');
+    // The transform reads the whole input before writing, so input === output
+    // rewrites the file safely.
+    await context.executeLuneTransformScriptAsync(
+      INJECT_SCRIPT_PATH,
+      rbxlPath,
+      rbxlPath,
+      JSON.stringify(attributes)
+    );
+  } finally {
+    await context.cleanupAsync();
+  }
+}
+
+/**
+ * True when the package at `packagePath` ships or directly depends on the
+ * manifest package, so its built place will contain the module to inject into.
+ * Gates injection during tests so unrelated packages don't pay for a Lune pass.
+ */
+export async function packageUsesManifestAsync(
+  packagePath: string
+): Promise<boolean> {
+  try {
+    const raw = await fs.readFile(
+      path.join(packagePath, 'package.json'),
+      'utf-8'
+    );
+    const pkg = JSON.parse(raw) as {
+      name?: string;
+      dependencies?: Record<string, string>;
+      devDependencies?: Record<string, string>;
+    };
+    if (pkg.name === MANIFEST_PACKAGE_NAME) {
+      return true;
+    }
+    return Boolean(
+      pkg.dependencies?.[MANIFEST_PACKAGE_NAME] ??
+        pkg.devDependencies?.[MANIFEST_PACKAGE_NAME]
+    );
+  } catch {
+    return false;
+  }
+}

package/src/utils/open-cloud/open-cloud-client.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import { OpenCloudClient } from './open-cloud-client.js';
+import type { RateLimiter } from './rate-limiter.js';
+
+vi.mock('@quenty/cli-output-helpers', () => ({
+  OutputHelper: {
+    verbose: vi.fn(),
+    warn: vi.fn(),
+    formatDim: (s: string) => s,
+    formatInfo: (s: string) => s,
+    formatError: (s: string) => s,
+    formatWarning: (s: string) => s,
+  },
+}));
+
+vi.mock('fs/promises', () => ({ readFile: vi.fn() }));
+
+describe('OpenCloudClient.uploadPlaceAsync', () => {
+  beforeEach(() => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      Buffer.from([1, 2, 3, 4, 5]) as unknown as string
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('streams the upload via an injected fetch impl and reports byte-level progress', async () => {
+    // The upload streams its body through node-fetch (injected as fetchImpl):
+    // undici cannot send a streaming request body to the Open Cloud endpoint on
+    // Node 24 ("expected non-null body source"), so the limiter must drive the
+    // Node-http-based client. The body is handed over as a per-attempt factory
+    // so each retry gets a fresh, un-disturbed stream; a counting Transform on
+    // it drives byte-level progress. Content-Length is set so it isn't chunked.
+    let capturedInit: RequestInit | undefined;
+    let capturedFetchImpl: unknown;
+    const fakeLimiter = {
+      fetchAsync: vi.fn(
+        async (
+          _url: string | URL,
+          init?: RequestInit | (() => RequestInit),
+          options?: { fetchImpl?: unknown }
+        ) => {
+          capturedInit = typeof init === 'function' ? init() : init;
+          capturedFetchImpl = options?.fetchImpl;
+          // Drain the streaming body so the counting Transform fires progress,
+          // exactly as the real transport would as it sends bytes.
+          const body = capturedInit?.body as AsyncIterable<Uint8Array>;
+          for await (const _chunk of body) {
+            void _chunk;
+          }
+          return new Response(JSON.stringify({ versionNumber: 7 }), {
+            status: 200,
+          });
+        }
+      ),
+    } as unknown as RateLimiter;
+
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: fakeLimiter,
+    });
+
+    const progress: Array<[number, number]> = [];
+    const version = await client.uploadPlaceAsync(
+      1,
+      2,
+      '/tmp/place.rbxl',
+      false,
+      (transferred, total) => progress.push([transferred, total])
+    );
+
+    expect(version).toBe(7);
+    // A dedicated fetch impl (node-fetch) is injected, not the global default.
+    expect(typeof capturedFetchImpl).toBe('function');
+    // Content-Length pins the length so node-fetch doesn't chunk the upload.
+    const headers = capturedInit?.headers as Record<string, string>;
+    expect(headers['Content-Length']).toBe('5');
+    // Byte-level progress: an initial 0, then cumulative up to the full size.
+    expect(progress[0]).toEqual([0, 5]);
+    expect(progress[progress.length - 1]).toEqual([5, 5]);
+  });
+
+  it('marks the version Published only when publish is true', async () => {
+    const urls: string[] = [];
+    const fakeLimiter = {
+      fetchAsync: vi.fn(
+        async (url: string | URL, init?: RequestInit | (() => RequestInit)) => {
+          urls.push(String(url));
+          // Drain the streamed body so the upload's Transform can complete.
+          const resolved = typeof init === 'function' ? init() : init;
+          const body = resolved?.body as AsyncIterable<Uint8Array> | undefined;
+          if (body) {
+            for await (const _chunk of body) {
+              void _chunk;
+            }
+          }
+          return new Response(JSON.stringify({ versionNumber: 1 }), {
+            status: 200,
+          });
+        }
+      ),
+    } as unknown as RateLimiter;
+
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: fakeLimiter,
+    });
+
+    await client.uploadPlaceAsync(1, 2, '/tmp/place.rbxl', true);
+    await client.uploadPlaceAsync(1, 2, '/tmp/place.rbxl', false);
+
+    expect(urls[0]).toContain('versionType=Published');
+    expect(urls[1]).toContain('versionType=Saved');
+  });
+});

package/src/utils/open-cloud/open-cloud-client.ts

@@ -1,6 +1,8 @@
 import * as fs from 'fs/promises';
+import { Readable, Transform } from 'node:stream';
+import nodeFetch from 'node-fetch';
 import { OutputHelper } from '@quenty/cli-output-helpers';
-import { RateLimiter } from './rate-limiter.js';
+import { RateLimiter, type FetchLike } from './rate-limiter.js';
 import {
   parseTestLogs,
   type ParsedTestLogs,
@@ -130,40 +132,35 @@ export class OpenCloudClient {
       'X-API-Key': apiKey,
     };
 
-    let response: Response;
-
-    if (onProgress) {
-      // Wrap the buffer in a ReadableStream that reports bytes as each chunk
-      // is consumed by the transport, giving real-time upload progress.
-      const CHUNK_SIZE = 64 * 1024;
-      let offset = 0;
-      const stream = new ReadableStream<Uint8Array>({
-        pull(controller) {
-          if (offset >= totalBytes) {
-            controller.close();
-            return;
-          }
-          const end = Math.min(offset + CHUNK_SIZE, totalBytes);
-          controller.enqueue(fileBuffer.subarray(offset, end));
-          offset = end;
-          onProgress(offset, totalBytes);
+    // Stream the place binary so we can report byte-level upload progress. We
+    // pin node-fetch here: undici (global fetch) cannot send a streaming request
+    // body to the Open Cloud versions endpoint on Node 24 — it throws "expected
+    // non-null body source" — whereas node-fetch's Node http stack accepts it.
+    // Content-Length is set so the upload isn't chunked. The rate limiter
+    // rebuilds this init per attempt, so each retry gets a fresh, un-disturbed
+    // stream (and progress restarts, correctly mirroring the re-sent bytes).
+    onProgress?.(0, totalBytes);
+    const makeUploadInit = (): RequestInit => {
+      let counted = 0;
+      const counter = new Transform({
+        transform(chunk, _enc, cb) {
+          counted += chunk.length;
+          onProgress?.(counted, totalBytes);
+          cb(null, chunk);
         },
       });
-
-      // fetch with ReadableStream body requires duplex: 'half' in Node
-      response = await this._rateLimiter.fetchAsync(url, {
+      // Node stream body: valid for node-fetch, but outside the DOM RequestInit
+      // type, so cast through unknown.
+      return {
         method: 'POST',
-        headers,
-        body: stream,
-        duplex: 'half',
-      } as RequestInit);
-    } else {
-      response = await this._rateLimiter.fetchAsync(url, {
-        method: 'POST',
-        headers,
-        body: new Uint8Array(fileBuffer),
-      });
-    }
+        headers: { ...headers, 'Content-Length': String(totalBytes) },
+        body: Readable.from(fileBuffer).pipe(counter),
+      } as unknown as RequestInit;
+    };
+
+    const response = await this._rateLimiter.fetchAsync(url, makeUploadInit, {
+      fetchImpl: nodeFetch as unknown as FetchLike,
+    });
 
     if (!response.ok) {
       const text = await response.text();

package/src/utils/open-cloud/rate-limiter.test.ts

@@ -197,4 +197,34 @@ describe('RateLimiter', () => {
     expect(response.status).toBe(404);
     expect(fetchMock).toHaveBeenCalledTimes(1);
   });
+
+  it('retries a transient HTML edge 400 but not a structured JSON API 400', async () => {
+    // A large upload can trip an edge proxy that answers 400 with an HTML body
+    // — transient framing noise we should ride out. A genuine Open Cloud 400 is
+    // a JSON error and must be returned immediately, not retried.
+    vi.useFakeTimers();
+    const limiter = new RateLimiter();
+
+    // Edge 400 (text/html) then success — must retry.
+    fetchMock
+      .mockResolvedValueOnce(makeResponse(400, { 'content-type': 'text/html' }))
+      .mockResolvedValueOnce(makeResponse(200));
+
+    const edge = limiter.fetchAsync('https://apis.roblox.com/cloud/v2/a');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(1000); // 2^0 = 1s backoff
+    expect((await edge).status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+
+    fetchMock.mockClear();
+
+    // API 400 (application/json) — must NOT retry.
+    fetchMock.mockResolvedValueOnce(
+      makeResponse(400, { 'content-type': 'application/json' })
+    );
+    const api = await limiter.fetchAsync('https://apis.roblox.com/cloud/v2/b');
+    expect(api.status).toBe(400);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
 });

package/src/utils/open-cloud/rate-limiter.ts

@@ -18,6 +18,17 @@ function _extractRoute(url: string | URL | Request): string {
   }
 }
 
+/**
+ * Minimal fetch shape the limiter drives. Defaults to the global `fetch`
+ * (undici). Callers can inject an alternative — e.g. node-fetch, whose Node
+ * `http` stack accepts a streaming request body against the Open Cloud upload
+ * endpoint where undici throws "expected non-null body source".
+ */
+export type FetchLike = (
+  url: string | URL | Request,
+  init?: RequestInit
+) => Promise<Response>;
+
 const DEFAULT_MAX_CONCURRENCY = 4;
 const DEFAULT_MAX_RETRIES = 6;
 const RETRY_JITTER_FRACTION = 0.3;
@@ -138,11 +149,13 @@ export class RateLimiter {
    */
   async fetchAsync(
     url: string | URL | Request,
-    init?: RequestInit
+    init?: RequestInit | (() => RequestInit),
+    options?: { fetchImpl?: FetchLike }
   ): Promise<Response> {
     await this._acquireAsync();
 
     const route = _extractRoute(url);
+    const doFetch = options?.fetchImpl ?? fetch;
 
     try {
       let lastResponse: Response | null = null;
@@ -155,13 +168,19 @@ export class RateLimiter {
         let transportError: unknown = null;
 
         try {
-          response = await fetch(url, init);
+          // Resolve init per attempt so a caller streaming a one-shot body
+          // (e.g. a progress-reporting upload) hands us a fresh, un-disturbed
+          // stream on every retry; a reused stream throws "body ... disturbed
+          // or locked". Plain-object inits (Uint8Array/string bodies) are just
+          // returned as-is and replay safely.
+          const resolvedInit = typeof init === 'function' ? init() : init;
+          response = await doFetch(url, resolvedInit);
           this._updateFromHeaders(response.headers);
         } catch (err) {
           transportError = err;
         }
 
-        if (response && !_isRetryableStatus(response.status)) {
+        if (response && !_isRetryableResponse(response)) {
           return response;
         }
 
@@ -198,8 +217,25 @@ export class RateLimiter {
   }
 }
 
-function _isRetryableStatus(status: number): boolean {
-  return status === 429 || RETRYABLE_SERVER_ERROR_STATUSES.has(status);
+function _isRetryableResponse(response: Response): boolean {
+  const { status } = response;
+  if (status === 429 || RETRYABLE_SERVER_ERROR_STATUSES.has(status)) {
+    return true;
+  }
+  // 408 Request Timeout is transient by definition.
+  if (status === 408) {
+    return true;
+  }
+  // A large upload occasionally trips an edge/proxy that answers 400 with an
+  // HTML body ("Your browser sent an invalid request") — transient framing
+  // noise, not the API rejecting the payload. A genuine Open Cloud 400 comes
+  // back as a structured JSON error and must NOT be retried, so gate on the
+  // content type: retry a 400 only when it isn't application/json.
+  if (status === 400) {
+    const contentType = response.headers.get('content-type') ?? '';
+    return !contentType.toLowerCase().includes('application/json');
+  }
+  return false;
 }
 
 function _computeWaitSeconds(

package/src/utils/testing/runner/test-runner.ts

@@ -8,6 +8,12 @@ import {
   parseTestLogs,
   parseTestCounts,
 } from '../test-log-parser.js';
+import {
+  buildDeployMetadataAttributes,
+  gatherGitDeployInfo,
+  injectDeployMetadataInPlaceAsync,
+  packageUsesManifestAsync,
+} from '../../deploy/deploy-metadata.js';
 
 export interface SingleTestResult {
   success: boolean;
@@ -60,6 +66,22 @@ export async function runSingleTestAsync(
     packageName,
   });
 
+  // Packages that ship or use the manifest get the same deploy-metadata stamp a
+  // real deploy would apply, so their specs can assert the injection actually
+  // ran. The per-session build is exclusively ours, so rewrite it in place.
+  if (await packageUsesManifestAsync(packagePath)) {
+    await injectDeployMetadataInPlaceAsync(
+      builtPlace.rbxlPath,
+      buildDeployMetadataAttributes(gatherGitDeployInfo(), {
+        target: 'test',
+        published: false,
+        timestamp: new Date().toISOString(),
+        placeId: builtPlace.target.placeId,
+        universeId: builtPlace.target.universeId,
+      })
+    );
+  }
+
   const scriptContent =
     scriptText ??
     (await readTestScriptAsync(packagePath, builtPlace.target.scriptTemplate));