refactor(tools): remove redundant limits and acknowledgements

This commit is contained in:
morluto
2026-09-29 10:53:45 +08:00
parent 7ba3580c86
commit bd0e341572
158 changed files with 599 additions and 1527 deletions
+1 -2
View File
@@ -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 &&
+3 -8
View File
@@ -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,
+2 -5
View File
@@ -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)
-1
View File
@@ -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 -81
View File
@@ -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 = (
+12 -12
View File
@@ -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;
+2 -2
View File
@@ -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,
+1 -1
View File
@@ -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",