scriptc/tests/harness/native-object-example.test.ts

import { execFileSync } from "node:child_process";
import {
  chmodSync,
  existsSync,
  mkdirSync,
  mkdtempSync,
  readFileSync,
  rmSync,
  writeFileSync,
} from "node:fs";
import { release as osRelease, tmpdir } from "node:os";
import { join } from "node:path";
import { afterAll, describe, expect, test } from "vitest";

const supported = process.platform === "darwin" && process.arch === "arm64" &&
  Number.parseInt(osRelease().split(".", 1)[0] ?? "", 10) >= 24;
const repoRoot = join(import.meta.dirname, "../..");
const fixture = join(repoRoot, "examples/native-object");
const scratch = mkdtempSync(join(tmpdir(), "scriptc-native-object-example-"));

afterAll(() => rmSync(scratch, { recursive: true, force: true }));

describe.runIf(supported)("external native object example", () => {
  test("rejects a stale runtime pack before invoking the toolchain", () => {
    const runtimeRoot = join(scratch, "stale-runtime");
    const traps = join(scratch, "stale-traps");
    const trapLog = join(scratch, "stale-toolchain.log");
    const linkInfo = join(scratch, "stale-link-info.json");
    mkdirSync(runtimeRoot, { recursive: true });
    mkdirSync(traps, { recursive: true });
    writeFileSync(join(runtimeRoot, "package.json"), JSON.stringify({
      name: "@scriptc/runtime",
      version: "2.0.0",
    }));
    const clang = join(traps, "clang");
    writeFileSync(clang, `#!/bin/sh\nprintf invoked > '${trapLog}'\nexit 97\n`);
    chmodSync(clang, 0o755);
    writeFileSync(linkInfo, JSON.stringify({
      schema: "scriptc.native-link-info.v1",
      runtime_pack: {
        package: "@scriptc/runtime",
        version: "1.0.0",
        root: runtimeRoot,
        objects: [], archives: [],
      },
      program: { object: join(scratch, "missing.o") },
      ffi: { libraries: [] },
      link: { driver_flags: [], system_libraries: [], frameworks: [] },
    }));

    let failure: { stderr?: Buffer } | null = null;
    try {
      execFileSync(process.execPath, [
        join(fixture, "link.mjs"), "cc", linkInfo, join(scratch, "stale-program"),
      ], {
        env: { ...process.env, PATH: `${traps}:${process.env["PATH"] ?? ""}` },
        stdio: "pipe",
      });
    } catch (error) {
      failure = error as { stderr?: Buffer };
    }
    expect(failure?.stderr?.toString("utf8")).toContain(
      "runtime pack identity mismatch: expected @scriptc/runtime@1.0.0",
    );
    expect(existsSync(trapLog)).toBe(false);
  });

  test("links and runs through both the C driver and Apple ld", () => {
    const nativeObject = join(scratch, "native.o");
    const programObject = join(scratch, "app.o");
    const manifest = join(scratch, "ffi.json");
    const linkInfo = join(scratch, "link-info.json");
    const raw = JSON.parse(readFileSync(join(fixture, "ffi.json"), "utf8")) as { libraries: string[] };
    raw.libraries = [nativeObject];
    writeFileSync(manifest, JSON.stringify(raw));
    execFileSync("clang", [
      "-target", "arm64-apple-macosx14.0.0", "-O2", "-c",
      join(fixture, "native.c"), "-o", nativeObject,
    ]);
    const json = execFileSync("node", [
      join(repoRoot, "packages/cli/dist/main.js"),
      "build", join(fixture, "main.ts"),
      "--ffi", manifest,
      "--print=native-link-info", "-o", programObject,
    ], { encoding: "utf8" });
    writeFileSync(linkInfo, json);

    for (const mode of ["cc", "ld"] as const) {
      const executable = join(scratch, `app-${mode}`);
      execFileSync("node", [join(fixture, "link.mjs"), mode, linkInfo, executable]);
      expect(execFileSync(executable, [], { encoding: "utf8" })).toBe("42\n");
    }
  }, 60_000);
});