mirror of
https://github.com/morluto/rea.git
synced 2026-11-22 14:35:45 +00:00
No V8 8.8 through 11.7 producer runs in the test environment, so the fixture is synthetic, as it already is for the narrow header: a real cache without its build-constant word and its alignment word, which is the container those releases define. Cover the admitted layout through the parser and the public CLI, the bit 31 module flag, a truncated six-word container, a container that fits both layouts, and the word-table rule for a 24-byte header. The short-header case now also covers the new 24-byte minimum. The CLI case is the recorded lifecycle coverage of the provider, so its new title is updated there as well.
157 lines
5.1 KiB
TypeScript
157 lines
5.1 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { expect } from "vitest";
|
|
import { toolContract } from "../../src/contracts/toolContracts.js";
|
|
import {
|
|
v8CodeCacheFixture,
|
|
withSyntheticLegacyHeader,
|
|
withSyntheticNarrowHeader,
|
|
} from "../../src/v8/V8CodeCache.fixture.js";
|
|
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
|
|
import { cliTest } from "../support/cli/cliFixture.js";
|
|
|
|
const outputSchema = toolContract("inspect_v8_code_cache").outputSchema;
|
|
|
|
cliTest(
|
|
"reports wide, synthetic narrow and synthetic six-word header extents through the public CLI",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-v8-cli-");
|
|
const wide = v8CodeCacheFixture();
|
|
const narrow = withSyntheticNarrowHeader(wide);
|
|
const legacy = withSyntheticLegacyHeader(wide);
|
|
const payloadDigest = createHash("sha256")
|
|
.update(wide.subarray(32))
|
|
.digest("hex");
|
|
for (const [bytes, headerBytes] of [
|
|
[wide, 32],
|
|
[narrow, 28],
|
|
[legacy, 24],
|
|
] as const) {
|
|
const path = join(root, `header-${String(headerBytes)}.jsc`);
|
|
await writeFile(path, bytes);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-v8-code-cache", path, "--json"],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const report = outputSchema.parse(result.json).normalized_result;
|
|
expect(report.header.magic).toBe(bytes.readUInt32LE(0));
|
|
expect(report.header.magic_build_stable).toBe(0xc0de);
|
|
expect(report.header.header_bytes).toBe(headerBytes);
|
|
expect(report.header.fields).toHaveLength(headerBytes / 4);
|
|
expect(report.payload.offset).toBe(headerBytes);
|
|
expect(report.payload.bytes).toBe(bytes.length - headerBytes);
|
|
expect(report.payload.sha256).toBe(payloadDigest);
|
|
expect(report.coverage.status).toBe("complete");
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"locates retained printable bytes from a working-directory-relative cache",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-v8-cli-strings-");
|
|
const path = join(root, "module.jsc");
|
|
const marker = "EMBEDDED_CONFIG_KEY_7c1d";
|
|
const bytes = v8CodeCacheFixture(
|
|
`var settings = { key: "${marker}" }; settings.key;`,
|
|
);
|
|
await writeFile(path, bytes);
|
|
const result = await cli.run({
|
|
arguments: [
|
|
"inspect-v8-code-cache",
|
|
"module.jsc",
|
|
"--minStringBytes",
|
|
"8",
|
|
"--json",
|
|
],
|
|
cwd: root,
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const report = outputSchema.parse(result.json).normalized_result;
|
|
const observation = report.embedded_strings.find((entry) =>
|
|
entry.text.includes(marker),
|
|
);
|
|
if (observation === undefined) throw new Error("Missing printable marker");
|
|
expect(report.artifact.path).toBe(path);
|
|
expect(observation.offset).toBeGreaterThanOrEqual(report.payload.offset);
|
|
expect(observation.offset + observation.bytes).toBeLessThanOrEqual(
|
|
report.artifact.bytes,
|
|
);
|
|
expect(
|
|
bytes
|
|
.subarray(
|
|
observation.offset,
|
|
observation.offset + observation.retained_bytes,
|
|
)
|
|
.toString("latin1"),
|
|
).toBe(observation.text);
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"fails closed on a file that is not a V8 code cache",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-v8-cli-foreign-");
|
|
const path = join(root, "random.bin");
|
|
const foreign = Buffer.from(v8CodeCacheFixture());
|
|
foreign.writeUInt32LE(0xdeadbeef, 0);
|
|
await writeFile(path, foreign);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-v8-code-cache", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.json).toMatchObject({
|
|
code: "unsupported_target",
|
|
details: {
|
|
operation: "inspect_v8_code_cache",
|
|
partial_observation: {
|
|
kind: "file-snapshot-hash",
|
|
path,
|
|
bytes: foreign.length,
|
|
sha256: createHash("sha256").update(foreign).digest("hex"),
|
|
},
|
|
},
|
|
});
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"retains file identity when a synthetic cache exceeds the string budget",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-v8-budget-");
|
|
const path = join(root, "synthetic.jsc");
|
|
const payload = Buffer.from("aaaa\0bbbb");
|
|
const bytes = Buffer.concat([
|
|
v8CodeCacheFixture().subarray(0, 32),
|
|
payload,
|
|
]);
|
|
bytes.writeUInt32LE(payload.length, 20);
|
|
await writeFile(path, bytes);
|
|
const result = await cli.run({
|
|
arguments: [
|
|
"inspect-v8-code-cache",
|
|
path,
|
|
"--max-strings",
|
|
"1",
|
|
"--min-string-bytes",
|
|
"4",
|
|
"--json",
|
|
],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(1);
|
|
expect(result.json).toMatchObject({
|
|
code: "resource_constraint",
|
|
details: {
|
|
reported_limits: { boundary: "max_strings", maximum: 1 },
|
|
partial_observation: {
|
|
kind: "file-snapshot-hash",
|
|
path,
|
|
bytes: bytes.length,
|
|
sha256: createHash("sha256").update(bytes).digest("hex"),
|
|
},
|
|
},
|
|
});
|
|
},
|
|
);
|