Files
rea/experiments/atomic-codemode/executor.test.mjs
T
f3f209d03f experiment(re)!: preserve partial captures and resolve function entries
Keep validated code available when native graph extraction is unavailable, bind output to the actual input/entry, preserve cancellation observations, and share batch source/error semantics. Add filtered function/alias reads and slice field selection across adapters.

Verified 38 focused tests, targeted lint, real stock/native MCP workflows, large SQLite graph-capacity fallback, and real cold/warm MCP reuse. Retain actual model costs and unequal-depth/selection limitations instead of claiming general superiority.

BREAKING CHANGE: Experimental native snapshots may succeed with readable code and an unavailable recovered_ir facet. Inspect facets before graph reads; unavailable graph counts are null/unknown.

Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>
2026-10-16 05:48:03 +00:00

90 lines
3.0 KiB
JavaScript

import test from "node:test";
import assert from "node:assert/strict";
import { executeJavaScript } from "./executor.mjs";
const fake = {
context: { lease: "test" },
call: async (name, input) => ({ ok: true, data: { name, input } }),
};
test("real QuickJS composes async API calls and does not expose host globals", async () => {
const result = await executeJavaScript(
fake,
'const a=await rea.strings({query:"x"}); const b=await rea.operations({ids:[a.data.name]}); return {a,b,host:[typeof process,typeof require,typeof fetch]};',
);
assert.equal(result.ok, true, JSON.stringify(result));
assert.deepEqual(result.value.host, ["undefined", "undefined", "undefined"]);
assert.equal(result.calls.length, 2);
assert.equal(result.value.b.data.input.ids[0], "strings");
});
test("infinite guest execution and never-resolving promises terminate", async () => {
const loop = await executeJavaScript(fake, "while(true){}", {
timeoutMs: 30,
});
assert.equal(loop.ok, false);
const stalled = await executeJavaScript(
fake,
"await new Promise(()=>{});return 1",
{ timeoutMs: 30 },
);
assert.equal(stalled.ok, false);
});
test("output budgets and failures survive without silently clipping evidence", async () => {
const result = await executeJavaScript(fake, 'return "x".repeat(40000)');
assert.equal(result.error.code, "output_budget");
const failure = await executeJavaScript(
fake,
'throw new Error("explicit failure")',
);
assert.equal(failure.ok, false);
});
test("guest CPU budget is independent from the native-analysis wall deadline", async () => {
const before = performance.now();
const result = await executeJavaScript(fake, "while(true){}", {
timeoutMs: 5000,
cpuBudgetMs: 25,
});
assert.equal(result.error.code, "cpu_budget");
assert.ok(performance.now() - before < 2000);
});
test("cancelled reads keep partial-observation Evidence in the execution receipt", async () => {
const result = await executeJavaScript(
{
context: { lease: "partial" },
call: async () => ({
ok: false,
error: {
code: "cancelled",
details: {
partial_observation: { source: { evidence_id: "ev_partial" } },
},
},
}),
},
"return await rea.strings({query:'x'})",
);
assert.deepEqual(result.evidence_ids, ["ev_partial"]);
assert.equal(result.value.error.code, "cancelled");
});
test("failed compositions keep completed facts and their provenance after draining", async () => {
const owner = {
context: { lease: "retained" },
call: async () => ({ ok: true, data: { evidence_id: "ev_retained" } }),
};
for (const ending of [
'throw new Error("after analysis")',
'return "x".repeat(40000)',
]) {
const result = await executeJavaScript(
owner,
`await rea.strings({}); ${ending}`,
);
assert.equal(result.ok, false);
assert.deepEqual(result.evidence_ids, ["ev_retained"]);
assert.deepEqual(result.context, owner.context);
assert.equal(result.calls[0].status, "ok");
}
});