Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
perf(javascript): reuse the source-analysis worker within a process (#5819)
morluto647717c050ff
diff --git a/scripts/rea.mjs b/scripts/rea.mjsindex ab1685154..321c801aa 100755--- a/scripts/rea.mjs+++ b/scripts/rea.mjs@@ -80,7 +80,7 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {writeStdout(result.output);process.exitCode = result.exitCode;} else {- const { cliConfigurationError, createCli } =+ const { cliConfigurationError, closeCliJavaScriptResources, createCli } =await import("../dist/cli-runtime/cli.js");const { createCliResultOutput } =await import("../dist/cli-runtime/cliResultOutput.js");@@ -94,47 +94,97 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {const cliArgs = normalizeCliArguments(args);const outputArguments = validateCliOutputArguments(cliArgs);const configurationError = cliConfigurationError(process.env);- // Doctor is the readiness report for this failure. Other commands still stop- // here so they do not run with an unusable log level.- if (configurationError !== undefined && !isDoctorCommand(cliArgs)) {- process.stderr.write(`${configurationError}\n`);- process.exitCode = 1;- } else if (!outputArguments.ok) {- writeStdout(renderCliOutputArgumentError(outputArguments));- process.exitCode = 1;- } else {- let wroteOutput = false;- const resultOutput = createCliResultOutput(cliArgs, process.stdout);- try {- await createCli(process.env, resultOutput).serve(cliArgs, {- stdout: (output) => {- if (resultOutput?.handled) {- if (resultOutput.failed && !stdoutClosed)- process.stderr.write(output);- return;- }- if (output.length > 0) wroteOutput = true;- writeStdout(output);- },- // A command failure caused by the closed pipe keeps the pipe's status.- exit: (code) => process.exit(stdoutClosed ? SIGPIPE_EXIT_STATUS : code),- });- } catch (cause) {- if (wroteOutput) throw cause;- const recovered = await resultOutput- ?.recoverFormattingFailure(cause)- .catch((writeFailure) => {- // Recovery writes outside Incur's command boundary. A reader that- // declined this document keeps the same quiet SIGPIPE outcome.- if (!stdoutClosed) throw writeFailure;- return true;+ let dispatchFailure;+ // Incur can exit from the callback below before this function returns.+ // That callback owns the status, including a closed-pipe exit of 141.+ let exiting = false;+ try {+ // Doctor is the readiness report for this failure. Other commands still stop+ // here so they do not run with an unusable log level.+ if (configurationError !== undefined && !isDoctorCommand(cliArgs)) {+ process.stderr.write(`${configurationError}\n`);+ process.exitCode = 1;+ } else if (!outputArguments.ok) {+ writeStdout(renderCliOutputArgumentError(outputArguments));+ process.exitCode = 1;+ } else {+ let wroteOutput = false;+ const resultOutput = createCliResultOutput(cliArgs, process.stdout);+ try {+ await createCli(process.env, resultOutput).serve(cliArgs, {+ stdout: (output) => {+ if (resultOutput?.handled) {+ if (resultOutput.failed && !stdoutClosed)+ process.stderr.write(output);+ return;+ }+ if (output.length > 0) wroteOutput = true;+ writeStdout(output);+ },+ // A command failure caused by the closed pipe keeps the pipe's status.+ // Worker shutdown is shared with the dispatch finally below. A failed+ // shutdown is reported here because this callback is what exits.+ exit: (code) => {+ exiting = true;+ const status = stdoutClosed ? SIGPIPE_EXIT_STATUS : code;+ void Promise.resolve()+ .then(() => closeCliJavaScriptResources())+ .then(+ () => {+ process.exit(status);+ },+ (cleanup) => {+ process.stderr.write(+ `Failed to close the JavaScript analysis worker: ${cleanupFailureText(cleanup)}\n`,+ );+ process.exit(+ stdoutClosed+ ? SIGPIPE_EXIT_STATUS+ : status === 0+ ? 1+ : status,+ );+ },+ );+ },});- if (!recovered) throw cause;- process.exitCode = stdoutClosed ? SIGPIPE_EXIT_STATUS : 1;+ } catch (cause) {+ if (wroteOutput) throw cause;+ const recovered = await resultOutput+ ?.recoverFormattingFailure(cause)+ .catch((writeFailure) => {+ // Recovery writes outside Incur's command boundary. A reader that+ // declined this document keeps the same quiet SIGPIPE outcome.+ if (!stdoutClosed) throw writeFailure;+ return true;+ });+ if (!recovered) throw cause;+ process.exitCode = stdoutClosed ? SIGPIPE_EXIT_STATUS : 1;+ }+ if (!wroteOutput && !resultOutput?.handled)+ writeStdout(renderEmptyFilteredCliOutput(cliArgs) ?? "");+ }+ } catch (cause) {+ dispatchFailure = cause;+ } finally {+ // Serve and output rendering can throw after a worker is parked. Stop it+ // on that path too, and keep the dispatch failure when both fail.+ try {+ await closeCliJavaScriptResources();+ } catch (cleanup) {+ // The exit callback reports this same shared failure and then exits.+ if (!exiting) {+ dispatchFailure =+ dispatchFailure === undefined+ ? cleanup+ : new AggregateError(+ [dispatchFailure, cleanup],+ "CLI dispatch failed and the JavaScript analysis worker remained owned",+ );+ }}- if (!wroteOutput && !resultOutput?.handled)- writeStdout(renderEmptyFilteredCliOutput(cliArgs) ?? "");}+ if (!exiting && dispatchFailure !== undefined) throw dispatchFailure;}/** True when the first positional command is `doctor`, after global output flags. */@@ -164,6 +214,11 @@ function isDoctorCommand(arguments_) {* with the status a SIGPIPE-terminated writer reports. MCP stdio keeps its own* client lifecycle.*/+function cleanupFailureText(cleanup) {+ if (cleanup instanceof Error) return cleanup.stack ?? cleanup.message;+ return String(cleanup);+}+function guardClosedStdout() {process.stdout.on("error", (cause) => {if (cause?.code === "EPIPE") {diff --git a/src/application/javascript/JavaScriptArtifactReconstruction.ts b/src/application/javascript/JavaScriptArtifactReconstruction.tsindex 1a2befbd9..2252e5a6b 100644--- a/src/application/javascript/JavaScriptArtifactReconstruction.ts+++ b/src/application/javascript/JavaScriptArtifactReconstruction.ts@@ -158,7 +158,7 @@ export const reconstructJavaScriptArtifact = async (? {}: { fileNodes: input.max_semantic_nodes_per_file }),});- const worker = createJavaScriptSourceAnalysis(+ const worker = await createJavaScriptSourceAnalysis({heapMb:input.max_heap_mb ?? JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.heapMb,@@ -169,6 +169,7 @@ export const reconstructJavaScriptArtifact = async (files.files.filter((file) => file.kind === "javascript" && file.text.included,).length,+ { scope },);let outcome;let cleanupFailure: AnalysisError | undefined;diff --git a/src/artifacts/ArtifactResourceScope.test.ts b/src/artifacts/ArtifactResourceScope.test.tsindex f9bffdb18..417e8ee6e 100644--- a/src/artifacts/ArtifactResourceScope.test.ts+++ b/src/artifacts/ArtifactResourceScope.test.ts@@ -55,6 +55,89 @@ it("waits for admitted operations and shares concurrent close", async () => {expect(closed).toBe(true);});+it("stops a close hook even when retained cleanup is still failing", async () => {+ const scope = new ArtifactResourceScope();+ let releases = 0;+ const owner = {+ kind: "lease" as const,+ resource: "stuck lease",+ lease: {+ async release() {+ releases += 1;+ if (releases < 3) throw new Error("still owned");+ },+ },+ };+ expect(await scope.release(owner)).toMatchObject({ kind: "failed" });+ let hookRuns = 0;+ scope.addCloseHook(async () => {+ hookRuns += 1;+ if (hookRuns === 1) throw new Error("hook still stopping");+ });++ const closeFailure = await scope.close().then(+ () => {+ throw new Error("close succeeded while cleanup and the hook failed");+ },+ (cause: unknown) => cause,+ );+ expect(closeFailure).toMatchObject({+ message: "Artifact cleanup remains incomplete: stuck lease, close hook",+ failedOwners: [owner],+ cleanup: {+ reason: "still owned; hook still stopping",+ resources: ["stuck lease", "close hook"],+ },+ });+ expect(closeFailure).toBeInstanceOf(ArtifactResourceRetryFailure);+ const causes = (closeFailure as ArtifactResourceRetryFailure).cause;+ expect(causes).toBeInstanceOf(AggregateError);+ expect(+ (causes as AggregateError).errors.map((error) =>+ error instanceof Error ? error.message : String(error),+ ),+ ).toEqual([+ "Artifact cleanup remains incomplete: stuck lease",+ "hook still stopping",+ ]);+ expect(releases).toBe(2);+ expect(hookRuns).toBe(1);+ await scope.close();+ expect(releases).toBe(3);+ expect(hookRuns).toBe(2);+});++it("runs later close hooks when an earlier hook fails", async () => {+ const scope = new ArtifactResourceScope();+ const order: string[] = [];+ scope.addCloseHook(async () => {+ order.push("first");+ throw new Error("first hook failed");+ });+ scope.addCloseHook(async () => {+ order.push("second");+ throw new Error("second hook failed");+ });++ const failure = await scope.close().then(+ () => {+ throw new Error("close succeeded while hooks failed");+ },+ (cause: unknown) => cause,+ );+ expect(order).toEqual(["first", "second"]);+ expect(failure).toBeInstanceOf(AggregateError);+ expect(+ (failure as AggregateError).errors.map((error) =>+ error instanceof Error ? error.message : String(error),+ ),+ ).toEqual(["first hook failed", "second hook failed"]);++ order.length = 0;+ await expect(scope.close()).rejects.toBeInstanceOf(AggregateError);+ expect(order).toEqual(["first", "second"]);+});+it("retains the same failed reader owner in a retry failure and retries before admitting work", async () => {const scope = new ArtifactResourceScope();let closeAttempts = 0;diff --git a/src/artifacts/ArtifactResourceScope.ts b/src/artifacts/ArtifactResourceScope.tsindex 9a7cf89e7..1b2848e76 100644--- a/src/artifacts/ArtifactResourceScope.ts+++ b/src/artifacts/ArtifactResourceScope.ts@@ -95,6 +95,8 @@ export class ArtifactResourceScope {>();readonly #active = new Set<Promise<unknown>>();#draining: Promise<void> | undefined;+ #closeInFlight: Promise<void> | undefined;+ readonly #closeHooks: Array<() => Promise<void>> = [];#closed = false;get hasPending(): boolean {@@ -203,10 +205,102 @@ export class ArtifactResourceScope {return this.#draining;}+ /**+ * Run after retained owners are released. Hooks stay registered so a later+ * close retries them, and a failing hook does not skip the ones after it.+ * Concurrent closes share one in-flight attempt.+ */+ addCloseHook(hook: () => Promise<void>): void {+ this.#closeHooks.push(hook);+ }+/** Stop admission, wait for active operations, and retry every retained owner. */close(): Promise<void> {this.#closed = true;- return this.retryCleanup();+ if (this.#closeInFlight !== undefined) return this.#closeInFlight;+ const attempt = this.#finishClose();+ let published: Promise<void>;+ published = attempt.finally(() => {+ if (this.#closeInFlight === published) this.#closeInFlight = undefined;+ });+ this.#closeInFlight = published;+ return published;+ }++ /** Every registered hook runs. One failure is returned unchanged; several are aggregated. */+ async #runCloseHooks(): Promise<unknown> {+ const failures: unknown[] = [];+ for (const hook of this.#closeHooks) {+ try {+ await hook();+ } catch (cause: unknown) {+ failures.push(cause);+ }+ }+ if (failures.length === 0) return undefined;+ if (failures.length === 1) return failures[0];+ return new AggregateError(+ failures,+ failures+ .map((cause) =>+ cause instanceof Error ? cause.message : String(cause),+ )+ .join("; "),+ );+ }++ async #finishClose(): Promise<void> {+ // A parked analyzer is not a pending owner. Stop it even when another+ // retained cleanup is still failing. A later close retries both.+ const cleanup = await this.retryCleanup().then(+ () => undefined,+ (cause: unknown) => cause,+ );+ const hookFailure = await this.#runCloseHooks();+ if (cleanup !== undefined && hookFailure !== undefined)+ throw this.#composeCloseFailures(cleanup, hookFailure);+ if (hookFailure !== undefined) throw hookFailure;+ if (cleanup !== undefined) throw cleanup;+ }++ /**+ * Report both outstanding owners. The pending set and the close hook stay+ * registered, so the next close retries each failed path.+ */+ #composeCloseFailures(+ cleanup: unknown,+ hookFailure: unknown,+ ): ArtifactReaderFailure {+ const retained = ArtifactReaderFailure.cleanupObservation(+ cleanup,+ "retained artifact cleanup",+ );+ const hook = ArtifactReaderFailure.cleanupObservation(+ hookFailure,+ "close hook",+ );+ const resources = [...new Set([...retained.resources, ...hook.resources])];+ const options = {+ cause: new AggregateError(+ [cleanup, hookFailure],+ "Retained cleanup and a close hook both failed",+ ),+ cleanup: {+ reason: `${retained.reason}; ${hook.reason}`,+ resources,+ },+ };+ const message = `Artifact cleanup remains incomplete: ${resources.join(", ")}`;+ if (cleanup instanceof ArtifactResourceRetryFailure)+ return new ArtifactResourceRetryFailure(+ cleanup.failedOwners.map((owner) => ({+ owner,+ lease: this.#lease(owner),+ })),+ message,+ options,+ );+ return new ArtifactReaderFailure("unavailable", message, options);}async #drainAndRetry(): Promise<void> {diff --git a/src/artifacts/javascript/JavaScriptSourceAnalysis.ts b/src/artifacts/javascript/JavaScriptSourceAnalysis.tsindex ac37fc75f..e30049e41 100644--- a/src/artifacts/javascript/JavaScriptSourceAnalysis.ts+++ b/src/artifacts/javascript/JavaScriptSourceAnalysis.ts@@ -3,10 +3,153 @@ import type {JavaScriptSourceAnalysisPort,} from "../../domain/javascript/javascriptSourceAnalysis.js";import { JavaScriptAnalysisWorker } from "../../javascript/analysis/JavaScriptAnalysisWorker.js";+import type { spawnOwnedProviderProcess } from "../../process/ProviderProcess.js";+import { ArtifactResourceScope } from "../ArtifactResourceScope.js";++interface RetainedJavaScriptSourceAnalysis {+ readonly worker: JavaScriptAnalysisWorker;+ readonly limits: JavaScriptSourceAnalysisLimits;+ busy: boolean;+}++const retained = new WeakMap<+ ArtifactResourceScope,+ RetainedJavaScriptSourceAnalysis+>();+const closeHookRegistered = new WeakSet<ArtifactResourceScope>();++export interface JavaScriptSourceAnalysisAcquisition {+ /** Keep a healthy worker until this scope closes. */+ readonly scope?: ArtifactResourceScope;+ /** Test seam. Reuse keeps the process already launched for the scope. */+ readonly launcher?: typeof spawnOwnedProviderProcess;+}/** Construct the inert artifact analyzer; resources are acquired on the first source. */export const createJavaScriptSourceAnalysis = (limits: JavaScriptSourceAnalysisLimits,sourceCount: number,-): JavaScriptSourceAnalysisPort =>- new JavaScriptAnalysisWorker(limits, undefined, sourceCount);+ acquisition: JavaScriptSourceAnalysisAcquisition = {},+): Promise<JavaScriptSourceAnalysisPort> => {+ if (acquisition.scope === undefined)+ return Promise.resolve(+ new JavaScriptAnalysisWorker(limits, acquisition.launcher, sourceCount),+ );+ return checkoutJavaScriptSourceAnalysis(+ acquisition.scope,+ limits,+ sourceCount,+ acquisition.launcher,+ );+};++const checkoutJavaScriptSourceAnalysis = async (+ scope: ArtifactResourceScope,+ limits: JavaScriptSourceAnalysisLimits,+ sourceCount: number,+ launcher: typeof spawnOwnedProviderProcess | undefined,+): Promise<JavaScriptSourceAnalysisPort> => {+ registerJavaScriptSourceAnalysisClose(scope);+ const current = retained.get(scope);+ if (current !== undefined && !current.busy) {+ if (+ sameLimits(current.limits, limits) &&+ current.worker.prepareForAnotherAnalysis(sourceCount)+ ) {+ current.busy = true;+ return new ScopeJavaScriptSourceAnalysis(scope, current.worker);+ }+ retained.delete(scope);+ try {+ await current.worker.close();+ } catch (cause) {+ // The old process is still alive. Keep it owned and fail this request+ // before another worker is constructed, including on MCP where the+ // analysis result is returned without a later cleanup retry.+ if (retained.get(scope) === undefined) {+ retained.set(scope, {+ worker: current.worker,+ limits: current.limits,+ busy: false,+ });+ } else {+ scope.retain({+ kind: "lease",+ resource: "replaced JavaScript source analyzer",+ lease: { release: () => current.worker.close() },+ });+ }+ throw cause;+ }+ }+ const worker = new JavaScriptAnalysisWorker(limits, launcher, sourceCount);+ // A concurrent analysis may have parked another healthy worker while the+ // replaced process was closing. Claim the slot only when it is still empty.+ // This extra process is closed through the port returned below.+ if (retained.get(scope) === undefined)+ retained.set(scope, { worker, limits, busy: true });+ return new ScopeJavaScriptSourceAnalysis(scope, worker);+};++const registerJavaScriptSourceAnalysisClose = (+ scope: ArtifactResourceScope,+): void => {+ if (closeHookRegistered.has(scope)) return;+ closeHookRegistered.add(scope);+ scope.addCloseHook(async () => {+ const current = retained.get(scope);+ if (current === undefined) return;+ await current.worker.close();+ if (retained.get(scope) === current) retained.delete(scope);+ });+};++const sameLimits = (+ left: JavaScriptSourceAnalysisLimits,+ right: JavaScriptSourceAnalysisLimits,+): boolean =>+ left.heapMb === right.heapMb && left.timeoutMs === right.timeoutMs;++/**+ * Park a healthy worker on its scope. The next checkout with the same limits+ * reuses that process; scope close is what actually stops it.+ */+class ScopeJavaScriptSourceAnalysis implements JavaScriptSourceAnalysisPort {+ #failed = false;+ #closed = false;++ constructor(+ private readonly scope: ArtifactResourceScope,+ private readonly worker: JavaScriptAnalysisWorker,+ ) {}++ analyze(+ ...args: Parameters<JavaScriptSourceAnalysisPort["analyze"]>+ ): ReturnType<JavaScriptSourceAnalysisPort["analyze"]> {+ return this.worker.analyze(...args).then((result) => {+ if (!result.ok) this.#failed = true;+ return result;+ });+ }++ async close(): Promise<void> {+ if (this.#closed) return;+ this.#closed = true;+ try {+ const current = retained.get(this.scope);+ if (+ current?.worker === this.worker &&+ !this.#failed &&+ this.worker.canReuse()+ ) {+ current.busy = false;+ return;+ }+ if (current?.worker === this.worker) retained.delete(this.scope);+ await this.worker.close();+ } catch (cause) {+ this.#closed = false;+ throw cause;+ }+ }+}diff --git a/src/cli.ts b/src/cli.tsindex d7e9e72ad..586942bcd 100644--- a/src/cli.ts+++ b/src/cli.ts@@ -58,6 +58,8 @@ import {import { registerReverseEngineeringCommands } from "./cli/reverseEngineeringCommands.js";import { registerCutterCommands } from "./cli/cutterCommands.js";+export { closeCliJavaScriptResources } from "./cli/javascriptApplicationAnalysis.js";+/*** Describe CLI settings that are invalid before any command runs, as MCP does.* Keep this aligned with PROCESS_START_CONFIGURATION_SETTINGS.diff --git a/src/cli/javascriptApplicationAnalysis.ts b/src/cli/javascriptApplicationAnalysis.tsindex e2f171bec..f4fcc9557 100644--- a/src/cli/javascriptApplicationAnalysis.ts+++ b/src/cli/javascriptApplicationAnalysis.ts@@ -7,7 +7,43 @@ import { projectAnalysisError } from "../domain/analysisErrorProjection.js";import type { JsonValue } from "../domain/jsonValue.js";import { ProviderCleanupError } from "../domain/providerCleanupError.js";-/** Execute the shared one-shot CLI boundary for static JavaScript analysis. */+/**+ * One scope for every JavaScript analysis in this process. A healthy worker+ * stays parked between commands; {@link closeCliJavaScriptResources} stops it.+ * Pending cleanup is still retried before each command returns.+ */+let retainedScope: ArtifactResourceScope | undefined;+/** One shutdown shared by the exit callback and the dispatch `finally`. */+let closing: Promise<void> | undefined;++const cliAnalysisScope = (): ArtifactResourceScope => {+ retainedScope ??= new ArtifactResourceScope();+ return retainedScope;+};++/**+ * Stop the process-owned JavaScript worker. Callers that overlap share the+ * attempt in flight. The scope stays owned when shutdown fails, so the next+ * call retries instead of treating the worker as already released.+ */+export const closeCliJavaScriptResources = (): Promise<void> => {+ if (closing !== undefined) return closing;+ const scope = retainedScope;+ if (scope === undefined) return Promise.resolve();+ let published: Promise<void>;+ published = scope+ .close()+ .then(() => {+ if (retainedScope === scope) retainedScope = undefined;+ })+ .finally(() => {+ if (closing === published) closing = undefined;+ });+ closing = published;+ return published;+};++/** Execute the shared CLI boundary for static JavaScript analysis. */export const runCliJavaScriptApplicationAnalysis = async (input: unknown,signal?: AbortSignal,@@ -20,13 +56,14 @@ export const runCliJavaScriptApplicationAnalysis = async (},{ minimumIntervalMs: 0 },);- const resources = new ArtifactResourceScope();+ const resources = cliAnalysisScope();const result = await analyzeJavaScriptApplication(input, resources, {progress,...(signal === undefined ? {} : { signal }),});try {- await resources.close();+ // Retry failed owners without stopping a healthy parked worker.+ await resources.retryCleanup();} catch (cause: unknown) {const cleanup = ArtifactReaderFailure.cleanupObservation(cause,diff --git a/src/javascript/analysis/JavaScriptAnalysisWorker.ts b/src/javascript/analysis/JavaScriptAnalysisWorker.tsindex dea646d26..7f978e235 100644--- a/src/javascript/analysis/JavaScriptAnalysisWorker.ts+++ b/src/javascript/analysis/JavaScriptAnalysisWorker.ts@@ -105,7 +105,7 @@ export class JavaScriptAnalysisWorker {#parentCapacityExhausted = false;#sourcesRemaining: number | undefined;#deadline: ProviderStartupDeadline | undefined;- readonly #resultBudgetBytes: number;+ #resultBudgetBytes = 0;/** Null when the runtime enforces the V8 heap flags instead. */readonly #processMemoryLimitBytes: number | null;readonly #onStdout = (chunk: Buffer | string): void => {@@ -179,8 +179,50 @@ export class JavaScriptAnalysisWorker {this.#processMemoryLimitBytes = javaScriptWorkerMemoryLimitBytes(limits.heapMb,);- // Reserve host-side control, schema/Evidence work and a maximum record's- // transient copies. Admission also accounts for retained earlier files.+ this.#refreshResultBudget();+ }++ /**+ * Whether this idle process can analyze another application. A failed,+ * cancelled, or still-open job must not be reused.+ */+ canReuse(): boolean {+ return (+ this.#ready &&+ this.#activeJobId === undefined &&+ this.#primaryFailure === undefined &&+ this.#lastFailure === undefined &&+ this.#frames.length === 0 &&+ this.#pending === "" &&+ this.#runtime.inputFailure === undefined &&+ !this.#runtime.hasPendingCleanup &&+ this.#runtime.supervisor !== undefined+ );+ }++ /**+ * Reset per-analysis admission for one idle process. The worker heap limit+ * stays the one selected at launch; callers must not reuse across limits.+ */+ prepareForAnotherAnalysis(sourceCount: number): boolean {+ if (!this.canReuse()) return false;+ if (!Number.isSafeInteger(sourceCount) || sourceCount < 0)+ throw new RangeError(+ "JavaScript worker source count must be a nonnegative safe integer",+ );+ this.#sourcesRemaining = sourceCount;+ this.#estimatedRetainedBytes = 0;+ this.#parentCapacityExhausted = false;+ this.#applicationProjectionFailure = undefined;+ this.#refreshResultBudget();+ return true;+ }++ /**+ * Reserve host-side control, schema/Evidence work, and a maximum record's+ * transient copies. Admission also accounts for retained earlier files.+ */+ #refreshResultBudget(): void {this.#resultBudgetBytes = Math.max(0,Math.floor(diff --git a/tests/boundary/cli/cliJavaScriptResourceClose.test.ts b/tests/boundary/cli/cliJavaScriptResourceClose.test.tsnew file mode 100644index 000000000..2ba0873d3--- /dev/null+++ b/tests/boundary/cli/cliJavaScriptResourceClose.test.ts@@ -0,0 +1,66 @@+import { afterEach, expect, it } from "vitest";++import { ArtifactResourceScope } from "../../../src/artifacts/ArtifactResourceScope.js";+import {+ closeCliJavaScriptResources,+ runCliJavaScriptApplicationAnalysis,+} from "../../../src/cli/javascriptApplicationAnalysis.js";++const originalClose = ArtifactResourceScope.prototype.close;++afterEach(async () => {+ ArtifactResourceScope.prototype.close = originalClose;+ await closeCliJavaScriptResources();+});++/** Create the process-owned scope without starting a worker. */+const openCliScope = (): Promise<unknown> =>+ runCliJavaScriptApplicationAnalysis({});++it("retries JavaScript worker shutdown when the first close fails", async () => {+ let calls = 0;+ ArtifactResourceScope.prototype.close = function (+ this: ArtifactResourceScope,+ ) {+ calls += 1;+ if (calls === 1) return Promise.reject(new Error("worker still owned"));+ return originalClose.call(this);+ };++ await openCliScope();+ await expect(closeCliJavaScriptResources()).rejects.toThrow(+ "worker still owned",+ );+ expect(calls).toBe(1);+ await closeCliJavaScriptResources();+ expect(calls).toBe(2);+ await closeCliJavaScriptResources();+ expect(calls).toBe(2);+});++it("shares one in-flight JavaScript worker shutdown between callers", async () => {+ let calls = 0;+ let release = (): void => {};+ const gate = new Promise<void>((resolve) => {+ release = resolve;+ });+ ArtifactResourceScope.prototype.close = function (+ this: ArtifactResourceScope,+ ) {+ calls += 1;+ return gate.then(() => originalClose.call(this));+ };++ try {+ await openCliScope();+ const first = closeCliJavaScriptResources();+ const second = closeCliJavaScriptResources();+ expect(second).toBe(first);+ expect(calls).toBe(1);+ release();+ await first;+ expect(calls).toBe(1);+ } finally {+ release();+ }+});diff --git a/tests/boundary/cli/dispatcher.test.ts b/tests/boundary/cli/dispatcher.test.tsindex 316a2cff2..40b46736d 100644--- a/tests/boundary/cli/dispatcher.test.ts+++ b/tests/boundary/cli/dispatcher.test.ts@@ -4,32 +4,39 @@ import { join } from "node:path";import { describe, expect } from "vitest";import { workspaceCliTest } from "../../support/cli/workspaceCliFixture.js";+import type { TestWorkspace } from "../../support/workspace/workspaceFixture.js";++const CLI_OUTPUT_RUNTIME =+ "export const normalizeCliArguments = (args) => args; export const validateCliOutputArguments = () => ({ ok: true }); export const renderCliOutputArgumentError = () => ''; export const renderEmptyFilteredCliOutput = () => undefined;\n";++const installCliRuntime = async (+ workspace: TestWorkspace,+ cliSource: string,+ resultOutput = "export const createCliResultOutput = () => undefined;\n",+): Promise<void> => {+ await workspace.mkdir("scripts");+ await workspace.mkdir("dist/cli-runtime");+ await Promise.all([+ copyFile("scripts/rea.mjs", workspace.path("scripts/rea.mjs")),+ workspace.write(+ "package.json",+ JSON.stringify({ type: "module", version: "1.0.0" }),+ ),+ workspace.write("dist/cli-runtime/cli.js", cliSource),+ workspace.write("dist/cli-runtime/cliOutput.js", CLI_OUTPUT_RUNTIME),+ workspace.write("dist/cli-runtime/cliResultOutput.js", resultOutput),+ ]);+};describe("executable dispatcher", () => {workspaceCliTest("does not append recovery output after delegated stdout has begun",async ({ processes, workspace }) => {- await workspace.mkdir("scripts");- await workspace.mkdir("dist/cli-runtime");- await Promise.all([- copyFile("scripts/rea.mjs", workspace.path("scripts/rea.mjs")),- workspace.write(- "package.json",- JSON.stringify({ type: "module", version: "1.0.0" }),- ),- workspace.write(- "dist/cli-runtime/cli.js",- 'export const cliConfigurationError = () => undefined; export const createCli = () => ({ serve: (_args, options) => { options.stdout("first document\\n"); throw new RangeError("Invalid string length"); } });\n',- ),- workspace.write(- "dist/cli-runtime/cliOutput.js",- "export const normalizeCliArguments = (args) => args; export const validateCliOutputArguments = () => ({ ok: true }); export const renderCliOutputArgumentError = () => ''; export const renderEmptyFilteredCliOutput = () => undefined;\n",- ),- workspace.write(- "dist/cli-runtime/cliResultOutput.js",- 'export const createCliResultOutput = () => ({ handled: false, failed: false, recoverFormattingFailure: () => { process.stdout.write("unexpected second document"); return true; } });\n',- ),- ]);+ await installCliRuntime(+ workspace,+ 'export const cliConfigurationError = () => undefined; export const closeCliJavaScriptResources = () => {}; export const createCli = () => ({ serve: (_args, options) => { options.stdout("first document\\n"); throw new RangeError("Invalid string length"); } });\n',+ 'export const createCliResultOutput = () => ({ handled: false, failed: false, recoverFormattingFailure: () => { process.stdout.write("unexpected second document"); return true; } });\n',+ );const result = await processes.run(process.execPath,[workspace.path("scripts/rea.mjs"), "fixture"],@@ -60,7 +67,7 @@ describe("executable dispatcher", () => {),workspace.write("dist/cli-runtime/cli.js",- 'export const cliConfigurationError = () => undefined; export const createCli = () => ({ serve: (args) => process.stdout.write(JSON.stringify({ adapter: "cli", args })) });\n',+ 'export const cliConfigurationError = () => undefined; export const closeCliJavaScriptResources = () => {}; export const createCli = () => ({ serve: (args) => process.stdout.write(JSON.stringify({ adapter: "cli", args })) });\n',),workspace.write("dist/cli-runtime/cliOutput.js",@@ -155,3 +162,39 @@ describe("executable dispatcher", () => {},);});++describe("executable dispatcher JavaScript shutdown", () => {+ workspaceCliTest(+ "reports a failed JavaScript worker shutdown instead of exiting successfully",+ async ({ processes, workspace }) => {+ await installCliRuntime(+ workspace,+ 'export const cliConfigurationError = () => undefined; export const closeCliJavaScriptResources = () => Promise.reject(new Error("worker still owned")); export const createCli = () => ({ serve: (_args, options) => { options.exit(0); } });\n',+ );+ const result = await processes.run(+ process.execPath,+ [workspace.path("scripts/rea.mjs"), "fixture"],+ { cwd: workspace.root },+ );+ expect(result.exitCode).toBe(1);+ expect(result.stderr).toContain("worker still owned");+ },+ );++ workspaceCliTest(+ "keeps the closed-pipe status when JavaScript worker shutdown fails",+ async ({ processes, workspace }) => {+ await installCliRuntime(+ workspace,+ 'export const cliConfigurationError = () => undefined; export const closeCliJavaScriptResources = () => Promise.reject(new Error("worker still owned")); export const createCli = () => ({ serve: (_args, options) => { process.stdout.emit("error", Object.assign(new Error("broken pipe"), { code: "EPIPE" })); options.exit(0); } });\n',+ );+ const result = await processes.run(+ process.execPath,+ [workspace.path("scripts/rea.mjs"), "fixture"],+ { cwd: workspace.root },+ );+ expect(result.exitCode).toBe(141);+ expect(result.stderr).toContain("worker still owned");+ },+ );+});diff --git a/tests/boundary/filesystem/javascript-applications/javascriptApplicationService.test.ts b/tests/boundary/filesystem/javascript-applications/javascriptApplicationService.test.tsindex 4dbf49ae0..af7b0777c 100644--- a/tests/boundary/filesystem/javascript-applications/javascriptApplicationService.test.ts+++ b/tests/boundary/filesystem/javascript-applications/javascriptApplicationService.test.ts@@ -38,7 +38,7 @@ describe("JavaScript source selection cancellation boundary", () => {controller.signal,sourcePaths,);- const worker = createJavaScriptSourceAnalysis(+ const worker = await createJavaScriptSourceAnalysis({ heapMb: 512, timeoutMs: 30_000 },1,);diff --git a/tests/boundary/javascript/javascriptSourceAnalysisWorker.test.ts b/tests/boundary/javascript/javascriptSourceAnalysisWorker.test.tsindex ff7f56aba..117230e2e 100644--- a/tests/boundary/javascript/javascriptSourceAnalysisWorker.test.ts+++ b/tests/boundary/javascript/javascriptSourceAnalysisWorker.test.ts@@ -5,6 +5,8 @@ import { join } from "node:path";import { promisify } from "node:util";import { expect, it } from "vitest";import { JavaScriptAnalysisWorker } from "../../../src/javascript/analysis/JavaScriptAnalysisWorker.js";+import { createJavaScriptSourceAnalysis } from "../../../src/artifacts/javascript/JavaScriptSourceAnalysis.js";+import { ArtifactResourceScope } from "../../../src/artifacts/ArtifactResourceScope.js";import { cleanupOwnedProcessGroup } from "../../../src/process/ProcessOwnership.js";import type { OwnedProcessGroup } from "../../../src/process/ProcessOwnership.js";import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";@@ -90,6 +92,278 @@ it("reuses one real owned analyzer while retaining distinct source identities an}});+it("reuses one owned worker across analyses on the same resource scope", async () => {+ const scope = new ArtifactResourceScope();+ const launches: number[] = [];+ const exits = new Map<number, Promise<void>>();+ const launcher: typeof spawnOwnedProviderProcess = async (request) => {+ const previous = launches.at(-1);+ if (previous !== undefined) await exits.get(previous);+ const spawned = await spawnOwnedProviderProcess(request);+ const pid = spawned.process.pid;+ if (pid === undefined)+ throw new Error("Owned analyzer has no observed PID");+ exits.set(+ pid,+ new Promise((resolve) => {+ spawned.process.once("exit", () => {+ resolve();+ });+ }),+ );+ launches.push(pid);+ return spawned;+ };+ const limits = { heapMb: 128, timeoutMs: 30_000 };+ const first = source("first.mjs", "export const observed = 1;");+ const second = source("second.mjs", "export const observed = 2;");+ const files = [first, second];+ try {+ for (const file of files) {+ const worker = await createJavaScriptSourceAnalysis(limits, 1, {+ scope,+ launcher,+ });+ try {+ const result = await worker.analyze(file, {+ nodes: 100,+ unknowns: 100,+ });+ if (!result.ok) throw result.error.error;+ expect(result.value.javascript.parse_status).toBe("complete");+ } finally {+ await worker.close();+ }+ }+ expect(launches).toHaveLength(1);+ const replaced = await createJavaScriptSourceAnalysis(+ { heapMb: 256, timeoutMs: 30_000 },+ 1,+ { scope, launcher },+ );+ try {+ const result = await replaced.analyze(first, {+ nodes: 100,+ unknowns: 100,+ });+ if (!result.ok) throw result.error.error;+ expect(result.value.javascript.parse_status).toBe("complete");+ } finally {+ await replaced.close();+ }+ expect(launches).toHaveLength(2);+ await scope.close();+ const reopened = await createJavaScriptSourceAnalysis(limits, 1, {+ scope,+ launcher,+ });+ try {+ const result = await reopened.analyze(first, {+ nodes: 100,+ unknowns: 100,+ });+ if (!result.ok) throw result.error.error;+ } finally {+ await reopened.close();+ }+ expect(launches).toHaveLength(3);+ } finally {+ await scope.close();+ }+});++it("keeps a worker parked while a limit change closes the previous process", async () => {+ const scope = new ArtifactResourceScope();+ const launches: number[] = [];+ const exited = new Set<number>();+ const exits = new Map<number, Promise<void>>();+ const launcher: typeof spawnOwnedProviderProcess = async (request) => {+ const spawned = await spawnOwnedProviderProcess(request);+ const pid = spawned.process.pid;+ if (pid === undefined)+ throw new Error("Owned analyzer has no observed PID");+ exits.set(+ pid,+ new Promise((resolve) => {+ spawned.process.once("exit", () => {+ exited.add(pid);+ resolve();+ });+ }),+ );+ launches.push(pid);+ return spawned;+ };+ const limits = { heapMb: 128, timeoutMs: 30_000 };+ const file = source("parked.mjs", "export const observed = 1;");+ const originalClose = JavaScriptAnalysisWorker.prototype.close;+ let releaseClose = (): void => {};+ const gate = new Promise<void>((resolve) => {+ releaseClose = resolve;+ });+ let closeCalls = 0;+ let markCloseStarted = (): void => {};+ const closeStarted = new Promise<void>((resolve) => {+ markCloseStarted = resolve;+ });+ let replacement:+ | ReturnType<typeof createJavaScriptSourceAnalysis>+ | undefined;+ try {+ const initial = await createJavaScriptSourceAnalysis(limits, 1, {+ scope,+ launcher,+ });+ const first = await initial.analyze(file, { nodes: 100, unknowns: 100 });+ if (!first.ok) throw first.error.error;+ await initial.close();+ const replacedPid = launches[0];+ if (replacedPid === undefined)+ throw new Error("Replaced analyzer has no observed PID");++ JavaScriptAnalysisWorker.prototype.close = async function (+ this: JavaScriptAnalysisWorker,+ ) {+ closeCalls += 1;+ if (closeCalls === 1) {+ markCloseStarted();+ await gate;+ }+ return originalClose.call(this);+ };+ replacement = createJavaScriptSourceAnalysis(+ { heapMb: 256, timeoutMs: 30_000 },+ 1,+ { scope, launcher },+ );+ await closeStarted;++ const concurrent = await createJavaScriptSourceAnalysis(limits, 1, {+ scope,+ launcher,+ });+ const concurrentResult = await concurrent.analyze(file, {+ nodes: 100,+ unknowns: 100,+ });+ if (!concurrentResult.ok) throw concurrentResult.error.error;+ await concurrent.close();+ const parkedPid = launches[1];+ if (parkedPid === undefined)+ throw new Error("Parked analyzer has no observed PID");++ releaseClose();+ const extra = await replacement;+ const extraResult = await extra.analyze(file, {+ nodes: 100,+ unknowns: 100,+ });+ if (!extraResult.ok) throw extraResult.error.error;+ const extraPid = launches[2];+ if (extraPid === undefined)+ throw new Error("Replacement analyzer has no observed PID");+ await extra.close();+ await exits.get(replacedPid);+ await exits.get(extraPid);+ expect(exited.has(replacedPid)).toBe(true);+ expect(exited.has(extraPid)).toBe(true);+ expect(exited.has(parkedPid)).toBe(false);++ await scope.close();+ await exits.get(parkedPid);+ expect(exited.has(parkedPid)).toBe(true);+ } finally {+ JavaScriptAnalysisWorker.prototype.close = originalClose;+ releaseClose();+ const port = await replacement?.catch(() => undefined);+ await port?.close().catch(() => undefined);+ await scope.close();+ }+});++it("does not start a replacement when closing the previous worker fails", async () => {+ const scope = new ArtifactResourceScope();+ const launches: number[] = [];+ const exited = new Set<number>();+ const exits = new Map<number, Promise<void>>();+ const launcher: typeof spawnOwnedProviderProcess = async (request) => {+ const previous = launches.at(-1);+ if (previous !== undefined) await exits.get(previous);+ const spawned = await spawnOwnedProviderProcess(request);+ const pid = spawned.process.pid;+ if (pid === undefined)+ throw new Error("Owned analyzer has no observed PID");+ exits.set(+ pid,+ new Promise((resolve) => {+ spawned.process.once("exit", () => {+ exited.add(pid);+ resolve();+ });+ }),+ );+ launches.push(pid);+ return spawned;+ };+ const limits = { heapMb: 128, timeoutMs: 30_000 };+ const file = source("replaced.mjs", "export const observed = 1;");+ const originalClose = JavaScriptAnalysisWorker.prototype.close;+ let closeCalls = 0;+ try {+ const initial = await createJavaScriptSourceAnalysis(limits, 1, {+ scope,+ launcher,+ });+ const first = await initial.analyze(file, { nodes: 100, unknowns: 100 });+ if (!first.ok) throw first.error.error;+ await initial.close();+ const replacedPid = launches[0];+ if (replacedPid === undefined)+ throw new Error("Replaced analyzer has no observed PID");++ JavaScriptAnalysisWorker.prototype.close = async function (+ this: JavaScriptAnalysisWorker,+ ) {+ closeCalls += 1;+ if (closeCalls === 1) throw new Error("worker still owned");+ return originalClose.call(this);+ };+ await expect(+ createJavaScriptSourceAnalysis({ heapMb: 256, timeoutMs: 30_000 }, 1, {+ scope,+ launcher,+ }),+ ).rejects.toThrow("worker still owned");+ expect(launches).toEqual([replacedPid]);+ expect(exited.has(replacedPid)).toBe(false);++ JavaScriptAnalysisWorker.prototype.close = originalClose;+ const replacement = await createJavaScriptSourceAnalysis(+ { heapMb: 256, timeoutMs: 30_000 },+ 1,+ { scope, launcher },+ );+ try {+ const result = await replacement.analyze(file, {+ nodes: 100,+ unknowns: 100,+ });+ if (!result.ok) throw result.error.error;+ } finally {+ await replacement.close();+ }+ expect(launches).toHaveLength(2);+ expect(exited.has(replacedPid)).toBe(true);+ const replacementPid = launches[1];+ if (replacementPid === undefined)+ throw new Error("Replacement analyzer has no observed PID");+ expect(exited.has(replacementPid)).toBe(false);+ } finally {+ JavaScriptAnalysisWorker.prototype.close = originalClose;+ await scope.close();+ }+});+it("reports an actual startup deadline and closes its owned resources before subsequent analysis", async () => {const file = source("app.mjs", "export const observed = 7;");const expired = new JavaScriptAnalysisWorker({ heapMb: 128, timeoutMs: 1 });diff --git a/tests/boundary/javascriptSemanticTraceEvidence.test.ts b/tests/boundary/javascriptSemanticTraceEvidence.test.tsindex 25316c648..94157c130 100644--- a/tests/boundary/javascriptSemanticTraceEvidence.test.ts+++ b/tests/boundary/javascriptSemanticTraceEvidence.test.ts@@ -1,13 +1,13 @@import { mkdir, writeFile } from "node:fs/promises";import { join } from "node:path";-import { expect, it } from "vitest";+import { afterAll, expect, it } from "vitest";import { Ajv2020 } from "ajv/dist/2020.js";import { createApplicationMcpHarness } from "../fixtures/applicationMcpHarness.js";import { parseMcpToolError } from "../fixtures/mcpToolError.js";import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";-import { createCli } from "../../src/cli.js";+import { closeCliJavaScriptResources, createCli } from "../../src/cli.js";import { createEvidence, parseEvidence } from "../../src/domain/evidence.js";import type { JsonValue } from "../../src/domain/jsonValue.js";import { analysisCliErrorEnvelopeSchema } from "../../src/contracts/errorSchemas.js";@@ -18,6 +18,10 @@ import { resolveJavaScriptSemanticEvidence } from "../../src/domain/javascript/jconst SEMANTIC_GRAPH_ID = `jsrg_${"0".repeat(64)}`;+// In-process serve keeps the CLI worker for this file. Stop it before the+// worker process exits so the private runtime root is not left behind.+afterAll(closeCliJavaScriptResources);+it("reports invalid nested semantic graph Evidence as caller input through CLI and SDK MCP", async () => {const root = await createTestTempDirectory("rea-semantic-trace-input-");await mkdir(join(root, "src"));diff --git a/tests/support/cli/cliCommandSessionWorker.mjs b/tests/support/cli/cliCommandSessionWorker.mjsindex 63ce69542..683682542 100644--- a/tests/support/cli/cliCommandSessionWorker.mjs+++ b/tests/support/cli/cliCommandSessionWorker.mjs@@ -50,7 +50,7 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {process.exit(1);}-const { cliConfigurationError, createCli } =+const { cliConfigurationError, closeCliJavaScriptResources, createCli } =await import("../../../dist/cli-runtime/cli.js");const { createCliResultOutput } =await import("../../../dist/cli-runtime/cliResultOutput.js");@@ -89,7 +89,10 @@ process.stdin.on("data", (chunk) => {}});process.stdin.on("end", () => {- chain.finally(() => process.exit(0));+ chain.finally(async () => {+ await closeCliJavaScriptResources();+ process.exit(0);+ });});async function handle(value) {diff --git a/tests/support/cli/compiledCliWorker.mjs b/tests/support/cli/compiledCliWorker.mjsindex e8012c751..50b08093d 100644--- a/tests/support/cli/compiledCliWorker.mjs+++ b/tests/support/cli/compiledCliWorker.mjs@@ -1,7 +1,7 @@import { Writable } from "node:stream";import { createInterface } from "node:readline";-const { cliConfigurationError, createCli } =+const { cliConfigurationError, closeCliJavaScriptResources, createCli } =await import("../../../dist/cli-runtime/cli.js");const { createCliResultOutput } =await import("../../../dist/cli-runtime/cliResultOutput.js");@@ -137,3 +137,4 @@ for await (const line of lines) {if (line.trim().length === 0) continue;await acceptRequest(line);}+await closeCliJavaScriptResources();