scriptc/tests/harness/self-hosting-runtime-pack.test.ts

import { spawnSync } from "node:child_process";
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { expect, test } from "vitest";
import { analyzeInChild, compileInChild } from "./self-hosting-compiler-process.js";
import { NATIVE_TARGETS, nativeCodegenTarget } from "../../packages/compiler/src/backend/targets.js";
import type { NativeLinkFeatures } from "../../packages/compiler/src/backend/native-link-info.js";
import type { RuntimePackManifest } from "../../packages/compiler/src/backend/runtime-pack-core.js";

const root = join(import.meta.dirname, "../..");
const entry = join(root, "tests/fixtures/self-hosting/runtime-pack.ts");
const base: NativeLinkFeatures = {
  dynamic: false, regex: false, copying: false, textDecoderLegacy: false, fileHandle: false,
  fetch: false, netIsland: false, zlib: false, assert: false, inspect: false, dynInvoke: false,
  dc: false, dynAsync: false, events: false, emitter: false, symbol: false, bigint: false,
  searchParams: false, qs: false, parseArgs: false, stream: false, net: false, http: false,
  http2: false, dgram: false, watch: false, foreignFfi: false, nodeTest: false, tls: false, tlsCa: false,
};

test("runtime manifest validation and selection are entirely static", async () => {
  const coverage = await analyzeInChild(entry, { dynamic: false });
  expect(coverage.preflightFailed).toBe(false);
  expect(coverage.stats.statementsTotal).toBeGreaterThan(50);
  expect(coverage.stats.statementsFailed).toBe(0);
  expect(coverage.stats.statementsIsland).toBe(0);
  expect(coverage.stats.functionsSkipped).toBe(0);
});

for (const backend of ["llvm"] as const) {
  test(`native runtime manifest selection matches Node (${backend})`, async () => {
    const directory = mkdtempSync(join(process.platform === "win32" ? tmpdir() : "/tmp", "scriptc-pack-selection-"));
    try {
      const built = await compileInChild(entry, {
        outDir: directory, outPath: join(directory, "selection" + (process.platform === "win32" ? ".exe" : "")),
        backend, dynamic: false, optimization: "dev", sanitize: process.env["SCRIPTC_SAN"] === "1",
      });
      if (!built.ok) throw new Error(JSON.stringify(built.diagnostics));
      expect(built.backend).toBe(backend);
      const input = join(directory, "request.json");
      const check = (request: object, status: number, name: string) => {
        writeFileSync(input, JSON.stringify(request));
        const options = { cwd: root, timeout: 30_000, maxBuffer: 16 * 1024 * 1024 };
        const oracle = spawnSync(process.execPath, ["--import", "tsx", entry, input], options);
        const native = spawnSync(built.binaryPath, [input], { ...options, env: { ...process.env, PATH: "" } });
        for (const result of [oracle, native]) {
          expect(result.error, name).toBeUndefined();
          expect(result.signal, name).toBeNull();
          expect(result.status, `${name}: ${result.stderr}`).toBe(status);
        }
        if (status === 0) expect(JSON.parse(native.stdout.toString()), name).toEqual(JSON.parse(oracle.stdout.toString()));
        else expect(native.stdout.toString(), name).toBe(oracle.stdout.toString());
        expect(native.stderr, name).toEqual(oracle.stderr);
        return native.stdout.toString();
      };
      // The installed manifest exercises the actual predicates and variants.
      // Substitute each target identity to exercise validation on every host.
      const hostTarget = nativeCodegenTarget()!;
      const packageDir = join(root, "packages", hostTarget.runtimePackPackage.replace("@scriptc/", ""));
      const installed = JSON.parse(readFileSync(join(packageDir, "runtime-pack.json"), "utf8")) as RuntimePackManifest;
      for (const target of NATIVE_TARGETS) {
        const manifest: RuntimePackManifest = {
          ...installed, package: target.runtimePackPackage,
          target: { name: target.name, llvm_triple: target.llvmTriple, architecture: target.architecture,
            object_format: target.objectFormat, minimum_os: target.minimumOs },
          compiler: { ...installed.compiler, target: target.llvmTriple },
        };
        const request = {
          manifest, target, packageName: manifest.package, packageVersion: manifest.version,
          compilerVersion: manifest.version, features: base, flavor: "release",
        };
        check(request, 0, target.name + " base");
        if (target.name === hostTarget.name) {
          for (const name of Object.keys(base)) {
            check({ ...request, features: { ...base, [name]: true } }, 0, target.name + " " + name);
          }
          const all = Object.fromEntries(Object.keys(base).map((name) => [name, true]));
          check({ ...request, features: all, flavor: "dev" }, 0, target.name + " all");
        }
        check({ ...request, packageVersion: "mismatch" }, 1, "package version");
        check({ ...request, manifest: { ...manifest, target: { ...manifest.target, minimum_os: "other" } } }, 1, "target identity");
        check({ ...request, manifest: { ...manifest, runtime_abi: { version: 0, marker: "wrong" } } }, 1, "runtime ABI");
        check({ ...request, manifest: { ...manifest, flavors: {} } }, 1, "missing flavor");
        check({ ...request, manifest: { ...manifest, archives: [{ path: "../escape", sha256: "0".repeat(64), size: 1, id: "zlib", predicate: true }] } }, 1, "artifact traversal");
        check({ ...request, manifest: { ...manifest, system_libraries: [{ name: "m", predicate: { any: [1] } }] } }, 1, "invalid predicate");
      }
    } finally { rmSync(directory, { recursive: true, force: true }); }
  });
}