refactor(tools): remove redundant limits and acknowledgements
This commit is contained in:
@@ -6,7 +6,6 @@ import {
|
||||
EvidenceIntegrityError,
|
||||
NoBinaryOpenError,
|
||||
type AnalysisError,
|
||||
type EvidenceLimitError,
|
||||
} from "../domain/errors.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
import {
|
||||
@@ -150,7 +149,7 @@ export class AnalysisSnapshotCache {
|
||||
| undefined,
|
||||
mergeEvidence: (
|
||||
bundle: EvidenceBundle,
|
||||
) => Result<number, EvidenceIntegrityError | EvidenceLimitError>,
|
||||
) => Result<number, EvidenceIntegrityError>,
|
||||
): Result<number, AnalysisError> {
|
||||
if (
|
||||
active !== undefined &&
|
||||
|
||||
@@ -136,7 +136,7 @@ const browserParameters = (
|
||||
allowed_origins: input.allowed_origins,
|
||||
};
|
||||
if (!("target_id" in input)) return scope;
|
||||
if ("screenshot_approved" in input)
|
||||
if ("maximum_image_bytes" in input)
|
||||
return {
|
||||
...scope,
|
||||
target_id: input.target_id,
|
||||
@@ -171,13 +171,8 @@ const browserParameters = (
|
||||
include_storage_keys: input.include_storage_keys,
|
||||
include_storage_fingerprints: input.include_storage_fingerprints,
|
||||
limits: input.limits,
|
||||
source_capture_approved: input.source_capture_approved,
|
||||
...(input.include_script_sources && "analysis_limits" in input
|
||||
? {
|
||||
fetch_source_maps: input.fetch_source_maps,
|
||||
source_map_fetch_approved: input.source_map_fetch_approved,
|
||||
analysis_limits: input.analysis_limits,
|
||||
}
|
||||
...("fetch_source_maps" in input
|
||||
? { fetch_source_maps: input.fetch_source_maps }
|
||||
: {}),
|
||||
};
|
||||
};
|
||||
|
||||
@@ -33,7 +33,6 @@ export const createElectronActiveEvidence = (
|
||||
const scenarioProjection = (
|
||||
input: ElectronActiveObservationInput,
|
||||
): EvidenceObservation["parameters"] => ({
|
||||
approved: input.approved,
|
||||
executable_path: input.executable_path,
|
||||
application_path: input.application_path,
|
||||
application_root: input.application_root,
|
||||
|
||||
@@ -246,10 +246,7 @@ const addValidationObservations = (state: IpcGraphState): void => {
|
||||
for (const analyzed of state.context.analysis.files) {
|
||||
const { file, javascript } = analyzed;
|
||||
if (javascript === null) continue;
|
||||
const coverage = javascriptAnalysisCoverage(
|
||||
javascript,
|
||||
state.context.input,
|
||||
);
|
||||
const coverage = javascriptAnalysisCoverage(javascript);
|
||||
for (const validation of javascript.electron.sender_validations) {
|
||||
const handlerRecord = containingHandler(state.records, file, validation);
|
||||
const target =
|
||||
@@ -341,5 +338,5 @@ const coverageFor = (
|
||||
)?.javascript;
|
||||
return javascript === null || javascript === undefined
|
||||
? undefined
|
||||
: javascriptAnalysisCoverage(javascript, context.input);
|
||||
: javascriptAnalysisCoverage(javascript);
|
||||
};
|
||||
|
||||
@@ -28,7 +28,7 @@ export const addElectronNativeBoundaries = (
|
||||
for (const analyzed of context.analysis.files) {
|
||||
const { file, javascript } = analyzed;
|
||||
if (javascript === null) continue;
|
||||
const coverage = javascriptAnalysisCoverage(javascript, context.input);
|
||||
const coverage = javascriptAnalysisCoverage(javascript);
|
||||
for (const value of javascript.electron.native_addon_bindings)
|
||||
addNativeBinding({ context, file, value, coverage });
|
||||
}
|
||||
|
||||
@@ -37,7 +37,7 @@ export const addElectronWindowBoundaries = (
|
||||
for (const analyzed of context.analysis.files) {
|
||||
const { file, javascript } = analyzed;
|
||||
if (javascript === null) continue;
|
||||
const coverage = javascriptAnalysisCoverage(javascript, context.input);
|
||||
const coverage = javascriptAnalysisCoverage(javascript);
|
||||
for (const value of javascript.electron.browser_windows) {
|
||||
const source = electronFindingSourceNode(context, file, value.module_key);
|
||||
if (source !== undefined)
|
||||
|
||||
@@ -53,7 +53,6 @@ const parameters = (
|
||||
target_id: input.target_id,
|
||||
observation_ms: input.observation_ms,
|
||||
include_script_sources: input.include_script_sources,
|
||||
source_capture_approved: input.source_capture_approved,
|
||||
limits: input.limits,
|
||||
}
|
||||
: {}),
|
||||
|
||||
@@ -40,5 +40,4 @@ const parameters = (
|
||||
input: AnalyzeJavaScriptApplicationInput,
|
||||
): EvidenceObservation["parameters"] => ({
|
||||
format: input.format,
|
||||
limits: input.limits,
|
||||
});
|
||||
|
||||
@@ -53,7 +53,6 @@ export const analyzeJavaScriptApplicationValidated = async (
|
||||
{
|
||||
input_path: input.input_path,
|
||||
format: input.format,
|
||||
limits: input.limits,
|
||||
},
|
||||
options.signal,
|
||||
);
|
||||
|
||||
@@ -119,7 +119,6 @@ export const compareApplicationVersionsEvidenceValidated = (
|
||||
rootArtifactSha256: right.rootArtifactSha256,
|
||||
graph: right.graph,
|
||||
},
|
||||
limits: input.limits,
|
||||
leftNativeEvidence: leftNative,
|
||||
rightNativeEvidence: rightNative,
|
||||
});
|
||||
@@ -132,7 +131,6 @@ export const compareApplicationVersionsEvidenceValidated = (
|
||||
right_native_evidence_ids: rightNative.map(
|
||||
({ evidence_id: id }) => id,
|
||||
),
|
||||
limits: input.limits,
|
||||
},
|
||||
result,
|
||||
),
|
||||
|
||||
@@ -26,7 +26,7 @@ import type {
|
||||
JavaScriptSourceMapObservation,
|
||||
JavaScriptSourceMapOriginal,
|
||||
} from "./JavaScriptArtifactAnalysisTypes.js";
|
||||
import type { JavaScriptArtifactReconstructionInput } from "./JavaScriptArtifactReconstructionInput.js";
|
||||
import { JAVASCRIPT_APPLICATION_RESOURCE_LIMITS } from "./JavaScriptArtifactReconstructionInput.js";
|
||||
import { analyzeJavaScriptJsonModule } from "./JavaScriptJsonModules.js";
|
||||
|
||||
interface MutableArtifactAnalysis {
|
||||
@@ -40,60 +40,45 @@ interface MutableArtifactAnalysis {
|
||||
modules: number;
|
||||
parseFailures: number;
|
||||
truncatedScopes: number;
|
||||
sourceMapSources: number;
|
||||
}
|
||||
|
||||
interface ArtifactAnalysisContext {
|
||||
readonly state: MutableArtifactAnalysis;
|
||||
readonly input: JavaScriptArtifactReconstructionInput;
|
||||
readonly deadline: number;
|
||||
readonly now: () => number;
|
||||
}
|
||||
|
||||
/** Analyze selected text files under one shared AST, finding, module, and time budget. */
|
||||
/** Analyze every selected source under shared AST and parser safety bounds. */
|
||||
export const analyzeJavaScriptArtifactFiles = (
|
||||
fileSet: JavaScriptArtifactFileSet,
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
now: () => number,
|
||||
): JavaScriptArtifactAnalysis => {
|
||||
const state = emptyArtifactAnalysis();
|
||||
const context = {
|
||||
state,
|
||||
input,
|
||||
deadline: now() + input.limits.max_parse_milliseconds,
|
||||
deadline:
|
||||
now() + JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxParseMilliseconds,
|
||||
now,
|
||||
};
|
||||
for (const file of fileSet.files) analyzeArtifactFile(file, context);
|
||||
return finalizeArtifactAnalysis(state, input);
|
||||
return finalizeArtifactAnalysis(state);
|
||||
};
|
||||
|
||||
const finalizeArtifactAnalysis = (
|
||||
state: MutableArtifactAnalysis,
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
): JavaScriptArtifactAnalysis => {
|
||||
const omittedHtmlFindings = Math.max(
|
||||
0,
|
||||
state.htmlScripts.length + state.findings - input.limits.max_findings,
|
||||
);
|
||||
const findings = Math.min(
|
||||
input.limits.max_findings,
|
||||
state.findings + state.htmlScripts.length,
|
||||
);
|
||||
const sourceMapTruncations = state.sourceMaps.filter(
|
||||
({ status }) => status === "truncated",
|
||||
).length;
|
||||
const truncatedScopes =
|
||||
state.truncatedScopes +
|
||||
sourceMapTruncations +
|
||||
(omittedHtmlFindings > 0 ? 1 : 0);
|
||||
const truncatedScopes = state.truncatedScopes + sourceMapTruncations;
|
||||
return {
|
||||
files: state.files,
|
||||
packages: state.packages,
|
||||
json_modules: state.jsonModules,
|
||||
html_scripts: state.htmlScripts.slice(0, input.limits.max_findings),
|
||||
html_scripts: state.htmlScripts,
|
||||
source_maps: state.sourceMaps,
|
||||
visited_ast_nodes: state.visitedNodes,
|
||||
findings,
|
||||
findings: state.findings + state.htmlScripts.length,
|
||||
modules: state.modules,
|
||||
parse_failures: state.parseFailures,
|
||||
truncated_scopes: truncatedScopes,
|
||||
@@ -111,30 +96,18 @@ const analyzeArtifactFile = (
|
||||
file: JavaScriptArtifactFile,
|
||||
context: ArtifactAnalysisContext,
|
||||
): void => {
|
||||
const { state, input } = context;
|
||||
const { state } = context;
|
||||
addStructuredObservations(file, state);
|
||||
if (file.kind === "html" && file.text.included)
|
||||
state.htmlScripts.push(
|
||||
...parseHtmlScripts(
|
||||
file.path,
|
||||
file.text.value,
|
||||
Math.max(0, input.limits.max_findings - state.findings),
|
||||
),
|
||||
);
|
||||
state.htmlScripts.push(...parseHtmlScripts(file.path, file.text.value));
|
||||
if (file.kind === "source-map") addSourceMap(file, context);
|
||||
if (file.kind !== "javascript" || !file.text.included) {
|
||||
state.files.push({ file, javascript: null, semantic: null });
|
||||
return;
|
||||
}
|
||||
const remainingNodes = input.limits.max_ast_nodes - state.visitedNodes;
|
||||
const remainingFindings = input.limits.max_findings - state.findings;
|
||||
const remainingModules = input.limits.max_modules - state.modules;
|
||||
if (
|
||||
remainingNodes <= 0 ||
|
||||
remainingFindings <= 0 ||
|
||||
remainingModules <= 0 ||
|
||||
context.now() > context.deadline
|
||||
) {
|
||||
const remainingNodes =
|
||||
JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxAstNodes - state.visitedNodes;
|
||||
if (remainingNodes <= 0 || context.now() > context.deadline) {
|
||||
state.files.push({ file, javascript: null, semantic: null });
|
||||
state.truncatedScopes += 1;
|
||||
return;
|
||||
@@ -151,24 +124,20 @@ const analyzeArtifactFile = (
|
||||
parsed,
|
||||
{
|
||||
maxAstNodes: remainingNodes,
|
||||
maxFindings: remainingFindings,
|
||||
maxModules: remainingModules,
|
||||
maxFindings: Number.MAX_SAFE_INTEGER,
|
||||
maxModules: Number.MAX_SAFE_INTEGER,
|
||||
deadline: context.deadline,
|
||||
now: context.now,
|
||||
},
|
||||
);
|
||||
const staticFindings = findingCount(analysis);
|
||||
const semanticFindingBudget = Math.max(
|
||||
0,
|
||||
input.limits.max_findings - state.findings - staticFindings,
|
||||
);
|
||||
const semanticLimits: JavaScriptSemanticLimits = {
|
||||
...DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS,
|
||||
maxScopes: remainingNodes,
|
||||
maxBindings: remainingNodes,
|
||||
maxCallables: remainingNodes,
|
||||
maxReferences: remainingNodes,
|
||||
maxModuleLinks: semanticFindingBudget,
|
||||
maxModuleLinks: remainingNodes,
|
||||
};
|
||||
const semantics =
|
||||
analysis.parse_status === "complete" || analysis.parse_status === "partial"
|
||||
@@ -198,14 +167,8 @@ const addSourceMap = (
|
||||
const sourceMap = parseSourceMap(file, {
|
||||
deadline: context.deadline,
|
||||
now: context.now,
|
||||
maximumSources: Math.max(
|
||||
0,
|
||||
context.input.limits.max_source_map_sources -
|
||||
context.state.sourceMapSources,
|
||||
),
|
||||
});
|
||||
context.state.sourceMaps.push(sourceMap);
|
||||
context.state.sourceMapSources += sourceMap.sources.length;
|
||||
};
|
||||
|
||||
const emptyArtifactAnalysis = (): MutableArtifactAnalysis => ({
|
||||
@@ -219,7 +182,6 @@ const emptyArtifactAnalysis = (): MutableArtifactAnalysis => ({
|
||||
modules: 0,
|
||||
parseFailures: 0,
|
||||
truncatedScopes: 0,
|
||||
sourceMapSources: 0,
|
||||
});
|
||||
|
||||
const addStructuredObservations = (
|
||||
@@ -286,14 +248,13 @@ const unavailablePackage = (
|
||||
const parseHtmlScripts = (
|
||||
path: string,
|
||||
text: string,
|
||||
maximum: number,
|
||||
): JavaScriptHtmlScriptObservation[] => {
|
||||
const scripts: JavaScriptHtmlScriptObservation[] = [];
|
||||
const baseHref = htmlBaseHref(text);
|
||||
const pattern = /<script\b[^>]*\bsrc\s*=\s*(["'])([^"']+)\1[^>]*>/giu;
|
||||
for (const match of text.matchAll(pattern)) {
|
||||
const script = match[2]?.slice(0, 4_096);
|
||||
if (script === undefined || scripts.length >= maximum) break;
|
||||
if (script === undefined) continue;
|
||||
const start = match.index;
|
||||
scripts.push({
|
||||
html_path: path,
|
||||
@@ -315,7 +276,6 @@ const parseSourceMap = (
|
||||
context: {
|
||||
readonly deadline: number;
|
||||
readonly now: () => number;
|
||||
readonly maximumSources: number;
|
||||
},
|
||||
): JavaScriptSourceMapObservation => {
|
||||
if (!file.text.included) return unavailableSourceMap(file);
|
||||
@@ -349,11 +309,9 @@ const collectSourceMapOriginals = (
|
||||
context: {
|
||||
readonly deadline: number;
|
||||
readonly now: () => number;
|
||||
readonly maximumSources: number;
|
||||
},
|
||||
): JavaScriptSourceMapObservation => {
|
||||
const sources: JavaScriptSourceMapOriginal[] = [];
|
||||
let total = 0;
|
||||
for (const map of maps) {
|
||||
const names = map.sources;
|
||||
if (!Array.isArray(names))
|
||||
@@ -363,7 +321,7 @@ const collectSourceMapOriginals = (
|
||||
: [];
|
||||
const root = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
|
||||
for (const [index, raw] of names.entries()) {
|
||||
if (total % 1_024 === 0 && context.now() > context.deadline)
|
||||
if (sources.length % 1_024 === 0 && context.now() > context.deadline)
|
||||
return {
|
||||
path: file.path,
|
||||
sha256: file.sha256,
|
||||
@@ -377,8 +335,6 @@ const collectSourceMapOriginals = (
|
||||
file,
|
||||
"Source map contains a non-string source name.",
|
||||
);
|
||||
total += 1;
|
||||
if (sources.length >= context.maximumSources) continue;
|
||||
const content =
|
||||
typeof contents[index] === "string" ? contents[index] : null;
|
||||
sources.push({
|
||||
@@ -388,25 +344,14 @@ const collectSourceMapOriginals = (
|
||||
});
|
||||
}
|
||||
}
|
||||
const omitted = total - sources.length;
|
||||
return omitted === 0
|
||||
? {
|
||||
path: file.path,
|
||||
sha256: file.sha256,
|
||||
status: "included",
|
||||
sources,
|
||||
omitted_sources: 0,
|
||||
limitation: null,
|
||||
}
|
||||
: {
|
||||
path: file.path,
|
||||
sha256: file.sha256,
|
||||
status: "truncated",
|
||||
sources,
|
||||
omitted_sources: omitted,
|
||||
limitation:
|
||||
"Original-source inventory reached the approved source-map limit.",
|
||||
};
|
||||
return {
|
||||
path: file.path,
|
||||
sha256: file.sha256,
|
||||
status: "included",
|
||||
sources,
|
||||
omitted_sources: 0,
|
||||
limitation: null,
|
||||
};
|
||||
};
|
||||
|
||||
const unavailableSourceMap = (
|
||||
|
||||
@@ -14,7 +14,7 @@ import {
|
||||
} from "../artifacts/ArtifactReader.js";
|
||||
import { streamChunkToBuffer } from "../artifacts/StreamBytes.js";
|
||||
import type { ArtifactInventorySnapshot } from "./ArtifactInventory.js";
|
||||
import type { JavaScriptArtifactReconstructionInput } from "./JavaScriptArtifactReconstructionInput.js";
|
||||
import { JAVASCRIPT_APPLICATION_RESOURCE_LIMITS } from "./JavaScriptArtifactReconstructionInput.js";
|
||||
|
||||
/** Relevant file categories projected from the complete artifact inventory. */
|
||||
export type JavaScriptArtifactFileKind =
|
||||
@@ -79,7 +79,6 @@ interface Selection {
|
||||
}
|
||||
|
||||
interface ReadContext {
|
||||
readonly input: JavaScriptArtifactReconstructionInput;
|
||||
readonly expected: ReadonlyMap<string, ExpectedFile>;
|
||||
readonly expectedContainers: ReadonlyMap<string, JavaScriptArtifactContainer>;
|
||||
readonly selections: ReadonlyMap<string, Selection>;
|
||||
@@ -102,14 +101,12 @@ interface ReadTextInput {
|
||||
export const readJavaScriptArtifactFiles = async (
|
||||
reader: ArtifactReader,
|
||||
snapshot: ArtifactInventorySnapshot,
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
signal?: AbortSignal,
|
||||
): Promise<JavaScriptArtifactFileSet> => {
|
||||
const inventory = expectedInventory(snapshot);
|
||||
const expected = inventory.files;
|
||||
const selections = selectTextFiles(expected, input);
|
||||
const selections = selectTextFiles(expected);
|
||||
const context: ReadContext = {
|
||||
input,
|
||||
expected,
|
||||
expectedContainers: inventory.containers,
|
||||
selections,
|
||||
@@ -156,8 +153,9 @@ const visitReader = async (
|
||||
const path = normalizeArtifactPath(
|
||||
prefix === "" ? entry.path : `${prefix}/${entry.path}`,
|
||||
{
|
||||
maxDepth: context.input.limits.max_depth,
|
||||
maxPathBytes: context.input.limits.max_path_bytes,
|
||||
maxDepth: JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.artifact.maxDepth,
|
||||
maxPathBytes:
|
||||
JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.artifact.maxPathBytes,
|
||||
},
|
||||
);
|
||||
const nestedAsar = isFilesystemAsar(entry, path);
|
||||
@@ -229,7 +227,7 @@ const readTextIfSelected = async (
|
||||
};
|
||||
const bytes = await readBounded(
|
||||
await input.reader.open(input.entry, context.signal),
|
||||
context.input.limits.max_text_file_bytes,
|
||||
JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxTextFileBytes,
|
||||
context.signal,
|
||||
);
|
||||
const digest = createHash("sha256").update(bytes).digest("hex");
|
||||
@@ -290,7 +288,6 @@ const expectedInventory = (
|
||||
|
||||
const selectTextFiles = (
|
||||
files: ReadonlyMap<string, ExpectedFile>,
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
): ReadonlyMap<string, Selection> => {
|
||||
const selected = new Map<string, Selection>();
|
||||
let fileCount = 0;
|
||||
@@ -302,13 +299,16 @@ const selectTextFiles = (
|
||||
for (const file of ordered) {
|
||||
if (file.kind === "native-addon") continue;
|
||||
if (
|
||||
fileCount >= input.limits.max_text_files ||
|
||||
file.bytes > input.limits.max_text_file_bytes
|
||||
fileCount >= JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxTextFiles ||
|
||||
file.bytes > JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxTextFileBytes
|
||||
) {
|
||||
selected.set(file.path, { selected: false, reason: "file-limit" });
|
||||
continue;
|
||||
}
|
||||
if (bytes + file.bytes > input.limits.max_total_text_bytes) {
|
||||
if (
|
||||
bytes + file.bytes >
|
||||
JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxTotalTextBytes
|
||||
) {
|
||||
selected.set(file.path, { selected: false, reason: "byte-limit" });
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -9,7 +9,6 @@ import {
|
||||
export class JavaScriptArtifactGraphAccumulator {
|
||||
readonly #nodes = new Map<string, ApplicationNode>();
|
||||
readonly #edges = new Map<string, ApplicationEdge>();
|
||||
#omittedObservations = 0;
|
||||
|
||||
/** Create or merge one canonical node. */
|
||||
addNode(input: unknown): ApplicationNode {
|
||||
@@ -27,9 +26,7 @@ export class JavaScriptArtifactGraphAccumulator {
|
||||
);
|
||||
const observations = [...bySemanticId.entries()]
|
||||
.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
|
||||
.slice(0, 64)
|
||||
.map(([, observation]) => observation);
|
||||
this.#omittedObservations += Math.max(0, bySemanticId.size - 64);
|
||||
const merged = createJavaScriptApplicationNode({
|
||||
kind: existing.kind,
|
||||
identity: existing.identity,
|
||||
@@ -55,11 +52,6 @@ export class JavaScriptArtifactGraphAccumulator {
|
||||
edges(): readonly ApplicationEdge[] {
|
||||
return [...this.#edges.values()];
|
||||
}
|
||||
|
||||
/** Count distinct node observations omitted by the graph contract bound. */
|
||||
omittedObservations(): number {
|
||||
return this.#omittedObservations;
|
||||
}
|
||||
}
|
||||
|
||||
const observationInput = (
|
||||
|
||||
@@ -31,7 +31,7 @@ import {
|
||||
addJavaScriptPackageNodes,
|
||||
createJavaScriptArtifactRootNode,
|
||||
} from "./JavaScriptArtifactGraphStructure.js";
|
||||
import type { JavaScriptArtifactReconstructionInput } from "./JavaScriptArtifactReconstructionInput.js";
|
||||
import { JAVASCRIPT_APPLICATION_RESOURCE_LIMITS } from "./JavaScriptArtifactReconstructionInput.js";
|
||||
import { addElectronBoundaries } from "./ElectronBoundaryGraph.js";
|
||||
import {
|
||||
classifyElectronIpcPairings,
|
||||
@@ -43,7 +43,6 @@ export const buildJavaScriptArtifactGraph = (
|
||||
snapshot: ArtifactInventorySnapshot,
|
||||
fileSet: JavaScriptArtifactFileSet,
|
||||
analysis: JavaScriptArtifactAnalysis,
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
): JavaScriptApplicationGraph => {
|
||||
const accumulator = new JavaScriptArtifactGraphAccumulator();
|
||||
const root = createJavaScriptArtifactRootNode(accumulator, snapshot);
|
||||
@@ -52,7 +51,6 @@ export const buildJavaScriptArtifactGraph = (
|
||||
snapshot,
|
||||
fileSet,
|
||||
analysis,
|
||||
input,
|
||||
root,
|
||||
filesByPath: new Map(fileSet.files.map((file) => [file.path, file])),
|
||||
fileNodes: new Map(),
|
||||
@@ -87,9 +85,7 @@ export const buildJavaScriptArtifactGraph = (
|
||||
};
|
||||
|
||||
const graphCoverage = (context: JavaScriptArtifactGraphContext) => {
|
||||
const exactLimitOmissions =
|
||||
context.fileSet.limit_omitted_text_files +
|
||||
context.accumulator.omittedObservations();
|
||||
const exactLimitOmissions = context.fileSet.limit_omitted_text_files;
|
||||
const sourceMapPolicyGap = context.analysis.source_maps.some(
|
||||
({ status }) => status === "invalid",
|
||||
);
|
||||
@@ -109,20 +105,17 @@ const graphCoverage = (context: JavaScriptArtifactGraphContext) => {
|
||||
partialJavaScript;
|
||||
if (context.analysis.truncated_scopes > 0)
|
||||
return truncatedApplicationCoverage(
|
||||
reconstructionLimits(context.input),
|
||||
reconstructionLimits(),
|
||||
truncationOmittedCount(context),
|
||||
);
|
||||
if (exactLimitOmissions > 0)
|
||||
return truncatedApplicationCoverage(
|
||||
reconstructionLimits(context.input),
|
||||
reconstructionLimits(),
|
||||
exactLimitOmissions,
|
||||
);
|
||||
if (unknownGap)
|
||||
return partialApplicationCoverage(
|
||||
reconstructionLimits(context.input),
|
||||
null,
|
||||
);
|
||||
return completeApplicationCoverage(reconstructionLimits(context.input));
|
||||
return partialApplicationCoverage(reconstructionLimits(), null);
|
||||
return completeApplicationCoverage(reconstructionLimits());
|
||||
};
|
||||
|
||||
const truncationOmittedCount = (
|
||||
@@ -202,11 +195,6 @@ const graphLimitations = (
|
||||
"Native member names are requested by JavaScript syntax and are not verified binary exports in this workflow.",
|
||||
]
|
||||
: []),
|
||||
...(context.accumulator.omittedObservations() === 0
|
||||
? []
|
||||
: [
|
||||
"Repeated content identities exceeded the per-node observation bound; containment edges still preserve inventoried paths.",
|
||||
]),
|
||||
...(coverage === "complete"
|
||||
? []
|
||||
: [
|
||||
@@ -215,27 +203,26 @@ const graphLimitations = (
|
||||
];
|
||||
};
|
||||
|
||||
const reconstructionLimits = (input: JavaScriptArtifactReconstructionInput) => [
|
||||
const reconstructionLimits = () => [
|
||||
{
|
||||
name: "max-entries",
|
||||
value: input.limits.max_entries,
|
||||
value: JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.artifact.maxEntries,
|
||||
unit: "items" as const,
|
||||
},
|
||||
{
|
||||
name: "max-total-artifact-bytes",
|
||||
value: input.limits.max_total_artifact_bytes,
|
||||
value: JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.artifact.maxTotalBytes,
|
||||
unit: "bytes" as const,
|
||||
},
|
||||
{
|
||||
name: "max-text-files",
|
||||
value: input.limits.max_text_files,
|
||||
value: JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxTextFiles,
|
||||
unit: "items" as const,
|
||||
},
|
||||
{
|
||||
name: "max-total-text-bytes",
|
||||
value: input.limits.max_total_text_bytes,
|
||||
value: JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.maxTotalTextBytes,
|
||||
unit: "bytes" as const,
|
||||
},
|
||||
...javaScriptAnalysisLimits(input),
|
||||
{ name: "max-observations-per-node", value: 64, unit: "items" as const },
|
||||
...javaScriptAnalysisLimits(),
|
||||
];
|
||||
|
||||
@@ -23,7 +23,7 @@ export const addJavaScriptBundlerNodes = (
|
||||
const { file, javascript } = analyzed;
|
||||
const asset = context.assetNodes.get(file.path);
|
||||
if (javascript === null || asset === undefined) continue;
|
||||
const coverage = javascriptAnalysisCoverage(javascript, context.input);
|
||||
const coverage = javascriptAnalysisCoverage(javascript);
|
||||
const records: BundlerGraphRecord[] = [];
|
||||
for (const registration of javascript.bundler_registrations) {
|
||||
const input = {
|
||||
|
||||
@@ -20,7 +20,6 @@ import {
|
||||
staticInferenceEvidence,
|
||||
unavailableAstEvidence,
|
||||
} from "./JavaScriptArtifactGraphEvidence.js";
|
||||
import type { JavaScriptArtifactReconstructionInput } from "./JavaScriptArtifactReconstructionInput.js";
|
||||
import {
|
||||
resolveArtifactPathByContext,
|
||||
type ArtifactPathResolution,
|
||||
@@ -32,7 +31,6 @@ export interface JavaScriptArtifactGraphContext {
|
||||
readonly snapshot: ArtifactInventorySnapshot;
|
||||
readonly fileSet: JavaScriptArtifactFileSet;
|
||||
readonly analysis: JavaScriptArtifactAnalysis;
|
||||
readonly input: JavaScriptArtifactReconstructionInput;
|
||||
readonly root: ApplicationNode;
|
||||
readonly filesByPath: ReadonlyMap<string, JavaScriptArtifactFile>;
|
||||
readonly fileNodes: Map<string, ApplicationNode>;
|
||||
@@ -214,13 +212,12 @@ export const javascriptAnalysisCoverage = (
|
||||
analysis: NonNullable<
|
||||
JavaScriptArtifactAnalysis["files"][number]["javascript"]
|
||||
>,
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
): JavaScriptArtifactGraphCoverage =>
|
||||
analysis.parse_status === "complete"
|
||||
? completeApplicationCoverage(javaScriptAnalysisLimits(input))
|
||||
? completeApplicationCoverage(javaScriptAnalysisLimits())
|
||||
: analysis.parse_status === "truncated"
|
||||
? truncatedApplicationCoverage(javaScriptAnalysisLimits(input), null)
|
||||
: partialApplicationCoverage(javaScriptAnalysisLimits(input), null);
|
||||
? truncatedApplicationCoverage(javaScriptAnalysisLimits(), null)
|
||||
: partialApplicationCoverage(javaScriptAnalysisLimits(), null);
|
||||
|
||||
/** Stable identity for a fact scoped to one exact artifact. */
|
||||
export const artifactLocalIdentity = (
|
||||
@@ -348,28 +345,16 @@ export const sourceNodeFor = (
|
||||
? context.sourceModuleNodes.get(path)
|
||||
: context.moduleNodes.get(moduleLookupKey(path, moduleKey));
|
||||
|
||||
/** Named AST budgets committed to graph evidence coverage. */
|
||||
export const javaScriptAnalysisLimits = (
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
) => [
|
||||
/** Actual parser safety bounds committed to graph evidence coverage. */
|
||||
export const javaScriptAnalysisLimits = () => [
|
||||
{
|
||||
name: "max-ast-nodes",
|
||||
value: input.limits.max_ast_nodes,
|
||||
unit: "items" as const,
|
||||
},
|
||||
{
|
||||
name: "max-findings",
|
||||
value: input.limits.max_findings,
|
||||
unit: "items" as const,
|
||||
},
|
||||
{
|
||||
name: "max-modules",
|
||||
value: input.limits.max_modules,
|
||||
value: 2_000_000,
|
||||
unit: "items" as const,
|
||||
},
|
||||
{
|
||||
name: "max-parse-milliseconds",
|
||||
value: input.limits.max_parse_milliseconds,
|
||||
value: 30_000,
|
||||
unit: "milliseconds" as const,
|
||||
},
|
||||
];
|
||||
|
||||
@@ -10,6 +10,7 @@ import {
|
||||
completeApplicationCoverage,
|
||||
truncatedApplicationCoverage,
|
||||
} from "../domain/javascriptApplicationEvidenceSchemas.js";
|
||||
import { javaScriptAnalysisLimits } from "./JavaScriptArtifactGraphContext.js";
|
||||
import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
|
||||
|
||||
/** Project HTML renderer entrypoints and their local script assets. */
|
||||
@@ -94,13 +95,7 @@ export const addJavaScriptSourceMapOriginals = (
|
||||
const coverage =
|
||||
sourceMap.status === "truncated"
|
||||
? truncatedApplicationCoverage(
|
||||
[
|
||||
{
|
||||
name: "max-source-map-sources",
|
||||
value: context.input.limits.max_source_map_sources,
|
||||
unit: "items",
|
||||
},
|
||||
],
|
||||
javaScriptAnalysisLimits(),
|
||||
sourceMap.omitted_sources,
|
||||
)
|
||||
: completeApplicationCoverage();
|
||||
|
||||
@@ -47,7 +47,7 @@ export const addJavaScriptStaticFindings = (
|
||||
const { file, javascript } = analyzed;
|
||||
const asset = context.assetNodes.get(file.path);
|
||||
if (javascript === null || asset === undefined) continue;
|
||||
const coverage = javascriptAnalysisCoverage(javascript, context.input);
|
||||
const coverage = javascriptAnalysisCoverage(javascript);
|
||||
for (const value of javascript.references)
|
||||
addReference(context, { file, asset, value, coverage });
|
||||
for (const value of javascript.endpoints)
|
||||
|
||||
@@ -61,7 +61,7 @@ export const reconstructJavaScriptArtifact = async (
|
||||
const format = await resolveFormat(path, input);
|
||||
const snapshot = await scanCanonicalArtifactInventory(
|
||||
path,
|
||||
artifactLimitsForReconstruction(input),
|
||||
artifactLimitsForReconstruction(),
|
||||
{ signal },
|
||||
);
|
||||
if (snapshot.manifest.root_format !== format)
|
||||
@@ -71,22 +71,12 @@ export const reconstructJavaScriptArtifact = async (
|
||||
);
|
||||
const reader = createReader(path, format);
|
||||
try {
|
||||
const files = await readJavaScriptArtifactFiles(
|
||||
reader,
|
||||
snapshot,
|
||||
input,
|
||||
signal,
|
||||
);
|
||||
const analysis = analyzeJavaScriptArtifactFiles(files, input, () =>
|
||||
const files = await readJavaScriptArtifactFiles(reader, snapshot, signal);
|
||||
const analysis = analyzeJavaScriptArtifactFiles(files, () =>
|
||||
performance.now(),
|
||||
);
|
||||
abortIfNeeded(signal);
|
||||
const graph = buildJavaScriptArtifactGraph(
|
||||
snapshot,
|
||||
files,
|
||||
analysis,
|
||||
input,
|
||||
);
|
||||
const graph = buildJavaScriptArtifactGraph(snapshot, files, analysis);
|
||||
const semanticGraph = buildJavaScriptSemanticGraph({
|
||||
rootArtifactSha256: snapshot.manifest.root_sha256,
|
||||
applicationGraph: graph,
|
||||
|
||||
@@ -1,33 +1,35 @@
|
||||
import { z } from "zod";
|
||||
|
||||
import type { ArtifactLimits } from "../artifacts/ArtifactReader.js";
|
||||
import {
|
||||
JAVASCRIPT_APPLICATION_ANALYSIS_DEFAULT_LIMITS,
|
||||
javascriptApplicationAnalysisLimitsSchema,
|
||||
} from "../domain/javascriptApplicationAnalysis.js";
|
||||
|
||||
/** Resource safeguards for local artifact traversal and static parsing. */
|
||||
export const JAVASCRIPT_APPLICATION_RESOURCE_LIMITS = {
|
||||
artifact: {
|
||||
maxEntries: 8_000,
|
||||
maxTotalBytes: 512 * 1_024 * 1_024,
|
||||
maxEntryBytes: 128 * 1_024 * 1_024,
|
||||
maxCompressionRatio: 1_000,
|
||||
maxDepth: 64,
|
||||
maxPathBytes: 4_096,
|
||||
} satisfies ArtifactLimits,
|
||||
maxTextFiles: 5_000,
|
||||
maxTotalTextBytes: 128 * 1_024 * 1_024,
|
||||
maxTextFileBytes: 8 * 1_024 * 1_024,
|
||||
maxAstNodes: 2_000_000,
|
||||
maxParseMilliseconds: 30_000,
|
||||
} as const;
|
||||
|
||||
/** Local ASAR/directory reconstruction request. */
|
||||
export const javascriptArtifactReconstructionInputSchema = z.strictObject({
|
||||
input_path: z.string().min(1),
|
||||
format: z.enum(["auto", "asar", "directory"]).default("auto"),
|
||||
limits: javascriptApplicationAnalysisLimitsSchema.default(
|
||||
JAVASCRIPT_APPLICATION_ANALYSIS_DEFAULT_LIMITS,
|
||||
),
|
||||
});
|
||||
|
||||
/** Parsed bounded reconstruction request. */
|
||||
/** Parsed local reconstruction request. */
|
||||
export type JavaScriptArtifactReconstructionInput = z.infer<
|
||||
typeof javascriptArtifactReconstructionInputSchema
|
||||
>;
|
||||
|
||||
/** Project reconstruction limits into the shared artifact traversal policy. */
|
||||
export const artifactLimitsForReconstruction = (
|
||||
input: JavaScriptArtifactReconstructionInput,
|
||||
): ArtifactLimits => ({
|
||||
maxEntries: input.limits.max_entries,
|
||||
maxTotalBytes: input.limits.max_total_artifact_bytes,
|
||||
maxEntryBytes: input.limits.max_artifact_entry_bytes,
|
||||
maxCompressionRatio: input.limits.max_compression_ratio,
|
||||
maxDepth: input.limits.max_depth,
|
||||
maxPathBytes: input.limits.max_path_bytes,
|
||||
});
|
||||
/** Project private resource safeguards into the artifact traversal policy. */
|
||||
export const artifactLimitsForReconstruction = (): ArtifactLimits =>
|
||||
JAVASCRIPT_APPLICATION_RESOURCE_LIMITS.artifact;
|
||||
|
||||
@@ -31,13 +31,13 @@ export const analyzeJavaScriptJsonModule = (
|
||||
typeof value === "object" && value !== null && !Array.isArray(value)
|
||||
? Object.keys(value).sort(compareCodePoints)
|
||||
: [];
|
||||
const retained = keys.slice(0, 128);
|
||||
const retained = keys;
|
||||
return {
|
||||
path: file.path,
|
||||
sha256: file.sha256,
|
||||
status: "included",
|
||||
top_level_keys: retained,
|
||||
omitted_top_level_keys: keys.length - retained.length,
|
||||
omitted_top_level_keys: 0,
|
||||
limitation: null,
|
||||
};
|
||||
};
|
||||
|
||||
@@ -76,7 +76,7 @@ export const addJavaScriptSourceModules = (
|
||||
exportedName === null ? [] : [exportedName],
|
||||
)
|
||||
.sort(compareCodePoints);
|
||||
const retainedExports = [...new Set(exports)].slice(0, 128);
|
||||
const retainedExports = [...new Set(exports)];
|
||||
const source = context.accumulator.addNode({
|
||||
kind: "javascript-module",
|
||||
identity: artifactLocalIdentity(
|
||||
@@ -98,10 +98,7 @@ export const addJavaScriptSourceModules = (
|
||||
).length,
|
||||
export_relationships: exports.length,
|
||||
export_names: retainedExports,
|
||||
omitted_export_names: Math.max(
|
||||
0,
|
||||
exports.length - retainedExports.length,
|
||||
),
|
||||
omitted_export_names: 0,
|
||||
},
|
||||
evidence: astObservationEvidence({
|
||||
sha256: file.sha256,
|
||||
|
||||
@@ -160,7 +160,7 @@ export const prepareReplayPlan = async (
|
||||
"Perform no host filesystem writes and expose no host or external network",
|
||||
...(input.reproducer_export === undefined
|
||||
? []
|
||||
: ["Write one separately approved reproducer after sandbox cleanup"]),
|
||||
: ["Write one reproducer after sandbox cleanup"]),
|
||||
],
|
||||
reproducer_export:
|
||||
input.reproducer_export === undefined
|
||||
|
||||
@@ -49,10 +49,6 @@ import {
|
||||
addSemanticGraphRelation as addRelation,
|
||||
constructSemanticGraphNode as semanticNode,
|
||||
createSemanticGraphProjectionState as emptyState,
|
||||
MAX_APPLICATION_NODE_IDS_PER_SEMANTIC_NODE,
|
||||
MAX_SEMANTIC_GRAPH_NODES,
|
||||
MAX_SEMANTIC_GRAPH_RELATIONS,
|
||||
MAX_SEMANTIC_GRAPH_UNKNOWNS,
|
||||
type SemanticGraphProjectionState as BuilderState,
|
||||
} from "./JavaScriptSemanticGraphConstruction.js";
|
||||
|
||||
@@ -97,7 +93,7 @@ export const buildJavaScriptSemanticGraph = ({
|
||||
const semanticTruncated = analysis.files.some(
|
||||
({ semantic }) => semantic?.ir.coverage.status === "truncated",
|
||||
);
|
||||
const truncated = state.limitsReached.size > 0 || semanticTruncated;
|
||||
const truncated = semanticTruncated;
|
||||
const unknowns = [...state.unknowns.values()];
|
||||
return createJavaScriptSemanticGraph({
|
||||
schema: "JavaScriptSemanticRelationGraph",
|
||||
@@ -113,29 +109,7 @@ export const buildJavaScriptSemanticGraph = ({
|
||||
truncated,
|
||||
omitted_nodes: truncated ? null : 0,
|
||||
omitted_relations: truncated ? null : 0,
|
||||
limits: [
|
||||
{
|
||||
name: "max_nodes",
|
||||
value: MAX_SEMANTIC_GRAPH_NODES,
|
||||
unit: "items",
|
||||
},
|
||||
{
|
||||
name: "max_relations",
|
||||
value: MAX_SEMANTIC_GRAPH_RELATIONS,
|
||||
unit: "items",
|
||||
},
|
||||
{
|
||||
name: "max_unknowns",
|
||||
value: MAX_SEMANTIC_GRAPH_UNKNOWNS,
|
||||
unit: "items",
|
||||
},
|
||||
{
|
||||
name: "max_application_node_ids_per_semantic_node",
|
||||
value: MAX_APPLICATION_NODE_IDS_PER_SEMANTIC_NODE,
|
||||
unit: "items",
|
||||
},
|
||||
...semanticRecoveryLimits(analysis),
|
||||
],
|
||||
limits: [...semanticRecoveryLimits(analysis)],
|
||||
families: JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => ({
|
||||
family,
|
||||
status: semanticFamilyStatus(family, analysis, truncated),
|
||||
@@ -161,11 +135,6 @@ export const buildJavaScriptSemanticGraph = ({
|
||||
"Request extraction covers fetch, WebSocket, node:http/node:https construction, direct option fields, and exact local response consumers.",
|
||||
"Boundary extraction covers unshadowed JSON/global coercions plus parse and validation method candidates.",
|
||||
"Resource extraction covers built-in filesystem/network acquisition and exact local close/destroy/end handles.",
|
||||
...(truncated
|
||||
? [
|
||||
"Semantic graph projection reached one or more explicit hard limits.",
|
||||
]
|
||||
: []),
|
||||
],
|
||||
});
|
||||
};
|
||||
|
||||
@@ -18,28 +18,12 @@ import {
|
||||
unavailableSemanticRootEvidence,
|
||||
} from "./JavaScriptSemanticGraphEvidence.js";
|
||||
|
||||
/** Hard semantic graph node bound enforced during artifact projection. */
|
||||
export const MAX_SEMANTIC_GRAPH_NODES = 100_000;
|
||||
/** Hard semantic graph relation bound enforced during artifact projection. */
|
||||
export const MAX_SEMANTIC_GRAPH_RELATIONS = 200_000;
|
||||
/** Hard unresolved-frontier bound enforced across all analyzed files. */
|
||||
export const MAX_SEMANTIC_GRAPH_UNKNOWNS = 100_000;
|
||||
/** Maximum structural nodes linked to one exact semantic location. */
|
||||
export const MAX_APPLICATION_NODE_IDS_PER_SEMANTIC_NODE = 64;
|
||||
|
||||
type SemanticGraphProjectionLimit =
|
||||
| "max_application_node_ids_per_semantic_node"
|
||||
| "max_nodes"
|
||||
| "max_relations"
|
||||
| "max_unknowns";
|
||||
|
||||
/** Mutable local projection state hidden from graph callers. */
|
||||
export interface SemanticGraphProjectionState {
|
||||
readonly nodes: Map<string, JavaScriptSemanticGraphNode>;
|
||||
readonly relations: Map<string, JavaScriptSemanticGraphRelation>;
|
||||
readonly unknowns: Map<string, JavaScriptSemanticGraphUnknown>;
|
||||
readonly roots: Set<string>;
|
||||
readonly limitsReached: Set<SemanticGraphProjectionLimit>;
|
||||
readonly applicationNodeIdsByLocation: ReadonlyMap<string, readonly string[]>;
|
||||
}
|
||||
|
||||
@@ -73,9 +57,6 @@ export const createSemanticGraphProjectionState = (
|
||||
relations: new Map(),
|
||||
unknowns: new Map(),
|
||||
roots: new Set(),
|
||||
limitsReached: new Set(
|
||||
index.truncated ? ["max_application_node_ids_per_semantic_node"] : [],
|
||||
),
|
||||
applicationNodeIdsByLocation: index.identifiers,
|
||||
};
|
||||
};
|
||||
@@ -101,22 +82,18 @@ export const constructSemanticGraphNode = (
|
||||
evidence: observedSemanticEvidence(file, input.location),
|
||||
});
|
||||
|
||||
/** Retain one canonical node unless the hard graph bound was reached. */
|
||||
/** Retain one canonical semantic node. */
|
||||
export const addSemanticGraphNode = (
|
||||
state: SemanticGraphProjectionState,
|
||||
node: JavaScriptSemanticGraphNode,
|
||||
): JavaScriptSemanticGraphNode | null => {
|
||||
const existing = state.nodes.get(node.node_id);
|
||||
if (existing !== undefined) return existing;
|
||||
if (state.nodes.size >= MAX_SEMANTIC_GRAPH_NODES) {
|
||||
state.limitsReached.add("max_nodes");
|
||||
return null;
|
||||
}
|
||||
state.nodes.set(node.node_id, node);
|
||||
return node;
|
||||
};
|
||||
|
||||
/** Retain one non-self semantic relationship unless its hard bound was reached. */
|
||||
/** Retain one non-self semantic relationship. */
|
||||
export const addSemanticGraphRelation = (
|
||||
state: SemanticGraphProjectionState,
|
||||
input: SemanticRelationConstructionInput,
|
||||
@@ -138,23 +115,15 @@ export const addSemanticGraphRelation = (
|
||||
evidence: input.evidence ?? inferredSemanticEvidence(input.source),
|
||||
});
|
||||
if (state.relations.has(value.relation_id)) return;
|
||||
if (state.relations.size >= MAX_SEMANTIC_GRAPH_RELATIONS) {
|
||||
state.limitsReached.add("max_relations");
|
||||
return;
|
||||
}
|
||||
state.relations.set(value.relation_id, value);
|
||||
};
|
||||
|
||||
/** Retain one unresolved frontier unless the global graph bound was reached. */
|
||||
/** Retain one unresolved frontier. */
|
||||
export const addSemanticGraphUnknown = (
|
||||
state: SemanticGraphProjectionState,
|
||||
unknown: JavaScriptSemanticGraphUnknown,
|
||||
): void => {
|
||||
if (state.unknowns.has(unknown.unknown_id)) return;
|
||||
if (state.unknowns.size >= MAX_SEMANTIC_GRAPH_UNKNOWNS) {
|
||||
state.limitsReached.add("max_unknowns");
|
||||
return;
|
||||
}
|
||||
state.unknowns.set(unknown.unknown_id, unknown);
|
||||
};
|
||||
|
||||
@@ -187,7 +156,6 @@ const indexApplicationNodes = (
|
||||
nodes: JavaScriptApplicationGraph["nodes"],
|
||||
): {
|
||||
readonly identifiers: ReadonlyMap<string, readonly string[]>;
|
||||
readonly truncated: boolean;
|
||||
} => {
|
||||
const identifiers = new Map<string, Set<string>>();
|
||||
for (const node of nodes) {
|
||||
@@ -213,16 +181,13 @@ const indexApplicationNodes = (
|
||||
}
|
||||
}
|
||||
}
|
||||
let truncated = false;
|
||||
const indexed = new Map(
|
||||
[...identifiers].map(([key, values]) => {
|
||||
const sorted = [...values].sort();
|
||||
if (sorted.length > MAX_APPLICATION_NODE_IDS_PER_SEMANTIC_NODE)
|
||||
truncated = true;
|
||||
return [key, sorted.slice(0, MAX_APPLICATION_NODE_IDS_PER_SEMANTIC_NODE)];
|
||||
return [key, sorted];
|
||||
}),
|
||||
);
|
||||
return { identifiers: indexed, truncated };
|
||||
return { identifiers: indexed };
|
||||
};
|
||||
|
||||
const matchingApplicationNodeIds = (
|
||||
|
||||
@@ -107,7 +107,6 @@ export const executeNodeCharacterization = async (
|
||||
{
|
||||
...parsed.data.preparation.replay,
|
||||
mode: "execute",
|
||||
approved: true,
|
||||
plan_digest: plannedReplay.plan.plan_digest,
|
||||
},
|
||||
options,
|
||||
|
||||
@@ -20,7 +20,6 @@ import {
|
||||
import { emptyProcessCapture as emptyCapture } from "../domain/processCapture.fixture.js";
|
||||
|
||||
const base = {
|
||||
approved: true as const,
|
||||
executable: "/bin/sh",
|
||||
working_directory: "/tmp",
|
||||
};
|
||||
|
||||
@@ -6,7 +6,6 @@ import { parseProcessScenario } from "../domain/processCapture.js";
|
||||
describe("process capture permission request", () => {
|
||||
it("projects the complete adapter-neutral authority scope", () => {
|
||||
const scenario = parseProcessScenario({
|
||||
approved: true,
|
||||
executable: "/bin/tool",
|
||||
arguments: ["--probe"],
|
||||
working_directory: "/workspace",
|
||||
|
||||
@@ -18,9 +18,7 @@ import { ok } from "../domain/result.js";
|
||||
|
||||
const experiment = () =>
|
||||
processPairedExperimentSchema.parse({
|
||||
approved: true,
|
||||
shared_scenario: {
|
||||
approved: true,
|
||||
executable: "/bin/template",
|
||||
arguments: ["shared"],
|
||||
working_directory: "/tmp",
|
||||
|
||||
Reference in New Issue
Block a user