@eagleoutice/flowr 2.1.3 → 2.1.5

package/benchmark/slicer.js

@@ -64,7 +64,7 @@ class BenchmarkSlicer {
             criterion: [],
             autoSelectIf
         });
-        this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code');
+        this.loadedXml = (await this.measureCommonStep('parse', 'retrieve AST from R code')).parsed;
         this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
         this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information');
         this.pipeline.switchToRequestStage();

package/cli/repl/commands/repl-parse.js

@@ -95,7 +95,7 @@ exports.parseCommand = {
             shell,
             request: (0, retriever_1.requestFromInput)((0, retriever_1.removeRQuotes)(remainingLine.trim()))
         }).allRemainingSteps();
-        const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parse));
+        const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parse.parsed));
         output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));
     }
 };

package/cli/repl/commands/repl-query.js

@@ -9,7 +9,7 @@ const ansi_1 = require("../../../util/ansi");
 const schema_1 = require("../../../util/schema");
 const query_1 = require("../../../queries/query");
 const json_1 = require("../../../util/json");
-const query_schema_1 = require("../../../queries/query-schema");
+const query_print_1 = require("../../../queries/query-print");
 async function getDataflow(shell, remainingLine) {
     return await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
         shell,
@@ -19,7 +19,7 @@ async function getDataflow(shell, remainingLine) {
 function printHelp(output) {
     output.stderr(`Format: ${(0, ansi_1.italic)(':query "<query>" <code>', output.formatter)}`);
     output.stdout('The query is an array of query objects to represent multiple queries. Each query object may have the following properties:');
-    output.stdout((0, schema_1.describeSchema)(query_schema_1.AnyQuerySchema, output.formatter));
+    output.stdout((0, schema_1.describeSchema)(query_1.AnyQuerySchema, output.formatter));
     output.stdout(`\n\nThe example ${(0, ansi_1.italic)(':query "[{\\"type\\": \\"call-context\\", \\"callName\\": \\"mean\\" }]" mean(1:10)', output.formatter)} would return the call context of the mean function.`);
     output.stdout('As a convenience, we interpret any (non-help) string not starting with \'[\' as a regex for the simple call-context query.');
     output.stdout(`Hence, ${(0, ansi_1.italic)(':query "mean" mean(1:10)', output.formatter)} is equivalent to the above example.`);
@@ -38,7 +38,7 @@ async function processQueryArgs(line, shell, output) {
     let parsedQuery = [];
     if (query.startsWith('[')) {
         parsedQuery = JSON.parse(query);
-        const validationResult = query_schema_1.QueriesSchema.validate(parsedQuery);
+        const validationResult = query_1.QueriesSchema.validate(parsedQuery);
         if (validationResult.error) {
             output.stderr(`Invalid query: ${validationResult.error.message}`);
             printHelp(output);
@@ -64,8 +64,7 @@ exports.queryCommand = {
         const results = await processQueryArgs(remainingLine, shell, output);
         const totalEnd = Date.now();
         if (results) {
-            output.stdout(JSON.stringify(results));
-            output.stdout('Total time: ' + (totalEnd - totalStart) + 'ms');
+            output.stdout((0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.processed));
         }
     }
 };

package/cli/repl/server/connection.js

@@ -74,6 +74,9 @@ class FlowRServerConnection {
         this.logger = server_1.serverLog.getSubLogger({ name });
         this.socket.on('data', data => this.handleData(String(data)));
         this.socket.on('error', e => this.logger.error(`[${this.name}] Error while handling connection: ${String(e)}`));
+        this.socket.on('close', () => {
+            this.fileMap.clear();
+        });
         this.allowRSessionAccess = allowRSessionAccess;
     }
     currentMessageBuffer = '';
@@ -129,6 +132,8 @@ class FlowRServerConnection {
         this.logger.info(`[${this.name}] Received file analysis request for ${message.filename ?? 'unknown file'}${message.filetoken ? ' with token: ' + message.filetoken : ''}`);
         if (message.filetoken && this.fileMap.has(message.filetoken)) {
             this.logger.warn(`File token ${message.filetoken} already exists. Overwriting.`);
+            // explicitly delete the previous store
+            this.fileMap.delete(message.filetoken);
         }
         const tempFile = tmp.fileSync({ postfix: '.R' });
         const slicer = this.createPipelineExecutorForRequest(message, tempFile.name);
@@ -307,7 +312,7 @@ class FlowRServerConnection {
             return;
         }
         const request = requestResult.message;
-        this.logger.info(`[${this.name}] Received query request for query ${JSON.stringify(request.query)}`);
+        this.logger.info(`[${this.name}] Received query request`);
         const fileInformation = this.fileMap.get(request.filetoken);
         if (!fileInformation) {
             (0, send_1.sendMessage)(this.socket, {

package/cli/repl/server/messages/message-query.js

@@ -5,14 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.responseQueryMessage = exports.requestQueryMessage = void 0;
 const joi_1 = __importDefault(require("joi"));
-const query_schema_1 = require("../../../../queries/query-schema");
+const query_1 = require("../../../../queries/query");
 exports.requestQueryMessage = {
     type: 'request-query',
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('request-query').required().description('The type of the message.'),
         id: joi_1.default.string().optional().description('If you give the id, the response will be sent to the client with the same id.'),
         filetoken: joi_1.default.string().required().description('The filetoken of the file/data retrieved from the analysis request.'),
-        query: query_schema_1.QueriesSchema.required().description('The query to run on the file analysis information.')
+        query: query_1.QueriesSchema.required().description('The query to run on the file analysis information.')
     }).description('Request a query to be run on the file analysis information.')
 };
 exports.responseQueryMessage = {

package/cli/repl/server/net.js

@@ -17,7 +17,7 @@ class WebSocketServerWrapper {
         this.connectHandler = handler;
     }
     start(port) {
-        this.server = new ws_1.WebSocketServer({ port });
+        this.server = new ws_1.WebSocketServer({ port, maxPayload: 1024 * 1024 * 1024 * 1024 });
         server_1.serverLog.info('WebSocket-Server wrapper is active!');
         this.server.on('connection', c => this.connectHandler?.(new WebSocketWrapper(c)));
     }

package/cli/repl/server/send.js

@@ -2,16 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUnnamedSocketName = getUnnamedSocketName;
 exports.sendMessage = sendMessage;
-const server_1 = require("./server");
 const json_1 = require("../../../util/json");
 function getUnnamedSocketName(c) {
     return `${c.remoteAddress ?? '?'}@${c.remotePort ?? '?'}`;
 }
 function sendMessage(c, message) {
-    const msg = JSON.stringify(message, json_1.jsonReplacer);
-    if (server_1.serverLog.settings.minLevel >= 2 /* LogLevel.Debug */) {
-        server_1.serverLog.debug(`[${getUnnamedSocketName(c)}] sending message: ${msg}`);
-    }
-    c.write(`${msg}\n`);
+    return (0, json_1.superBigJsonStringify)(message, '\n', msg => {
+        c.write(msg);
+    });
 }
 //# sourceMappingURL=send.js.map

package/cli/repl/server/server.d.ts

@@ -11,9 +11,9 @@ export declare class FlowRServer {
     private readonly server;
     private readonly shell;
     private versionInformation;
-    private allowRSessionAccess;
+    private readonly allowRSessionAccess;
     /** maps names to the respective connection */
-    private connections;
+    private readonly connections;
     private nameCounter;
     constructor(shell: RShell, allowRSessionAccess: boolean, server?: Server);
     start(port: number): Promise<void>;

package/cli/repl/server/server.js

@@ -17,7 +17,7 @@ class FlowRServer {
     server;
     shell;
     versionInformation;
-    allowRSessionAccess = false;
+    allowRSessionAccess;
     /** maps names to the respective connection */
     connections = new Map();
     nameCounter = 0;

package/config.js

@@ -41,7 +41,7 @@ exports.flowrConfigFileSchema = joi_1.default.object({
 // we don't load from a config file at all by default unless setConfigFile is called
 let configFile = undefined;
 let configWorkingDirectory = process.cwd();
-let currentConfig;
+let currentConfig = undefined;
 function setConfigFile(file, workingDirectory = process.cwd(), forceLoad = false) {
     configFile = file;
     configWorkingDirectory = workingDirectory;

package/core/pipeline-executor.js

@@ -169,9 +169,10 @@ class PipelineExecutor {
      * _Without `expectedStepName`, please refrain from accessing the result, as you have no safeguards if the pipeline changes._
      */
     async nextStep(expectedStepName) {
+        const start = Date.now();
         const [step, result] = this._doNextStep(expectedStepName);
         const awaitedResult = await result;
-        this.output[step] = awaitedResult;
+        this.output[step] = { ...awaitedResult, '.meta': { timing: Date.now() - start } };
         this.stepCounter++;
         return { name: step, result: awaitedResult };
     }

package/core/steps/all/core/00-parse.d.ts

@@ -1,16 +1,20 @@
 import { internalPrinter } from '../../../print/print';
-import { parseToQuads } from '../../../print/parse-printer';
 import { PipelineStepStage } from '../../pipeline-step';
 import type { RShellExecutor } from '../../../../r-bridge/shell-executor';
 import type { RShell } from '../../../../r-bridge/shell';
 import type { RParseRequests } from '../../../../r-bridge/retriever';
+import type { QuadSerializationConfiguration } from '../../../../util/quads';
 export interface ParseRequiredInput {
     /** This is the {@link RShell} or {@link RShellExecutor} connection to be used to obtain the original parses AST of the R code */
     readonly shell: RShell | RShellExecutor;
     /** The request which essentially indicates the input to extract the AST from */
     readonly request: RParseRequests;
 }
-declare function processor(_results: unknown, input: Partial<ParseRequiredInput>): Promise<string>;
+export interface ParseStepOutput {
+    /** The parsed AST of the R code as given by the R parse side */
+    readonly parsed: string;
+}
+declare function processor(_results: unknown, input: Partial<ParseRequiredInput>): Promise<ParseStepOutput>;
 export declare const PARSE_WITH_R_SHELL_STEP: {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
@@ -19,8 +23,11 @@ export declare const PARSE_WITH_R_SHELL_STEP: {
     readonly executed: PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof internalPrinter;
-        readonly 2: (text: string) => string;
-        readonly 5: typeof parseToQuads;
+        readonly 2: {
+            (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+            (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+        };
+        readonly 5: ({ parsed }: ParseStepOutput, config: QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
     readonly requiredInput: ParseRequiredInput;

package/core/steps/all/core/00-parse.js

@@ -4,13 +4,13 @@ exports.PARSE_WITH_R_SHELL_STEP = void 0;
 const print_1 = require("../../../print/print");
 const parse_printer_1 = require("../../../print/parse-printer");
 const retriever_1 = require("../../../../r-bridge/retriever");
-function processor(_results, input) {
+async function processor(_results, input) {
     /* in the future, we want to expose all cases */
     if (Array.isArray(input.request)) {
-        return (0, retriever_1.retrieveParseDataFromRCode)(input.request[0], input.shell);
+        return { parsed: await (0, retriever_1.retrieveParseDataFromRCode)(input.request[0], input.shell) };
     }
     else {
-        return (0, retriever_1.retrieveParseDataFromRCode)(input.request, input.shell);
+        return { parsed: await (0, retriever_1.retrieveParseDataFromRCode)(input.request, input.shell) };
     }
 }
 exports.PARSE_WITH_R_SHELL_STEP = {
@@ -21,8 +21,8 @@ exports.PARSE_WITH_R_SHELL_STEP = {
     executed: 0 /* PipelineStepStage.OncePerFile */,
     printer: {
         [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
-        [2 /* StepOutputFormat.Json */]: text => text,
-        [5 /* StepOutputFormat.RdfQuads */]: parse_printer_1.parseToQuads
+        [2 /* StepOutputFormat.Json */]: JSON.stringify,
+        [5 /* StepOutputFormat.RdfQuads */]: ({ parsed }, config) => (0, parse_printer_1.parseToQuads)(parsed, config)
     },
     dependencies: [],
     requiredInput: undefined

package/core/steps/all/core/10-normalize.d.ts

@@ -3,12 +3,13 @@ import { normalizedAstToJson, normalizedAstToQuads, printNormalizedAstToMermaid,
 import { PipelineStepStage } from '../../pipeline-step';
 import type { IdGenerator } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NoInfo } from '../../../../r-bridge/lang-4.x/ast/model/model';
+import type { ParseStepOutput } from './00-parse';
 export interface NormalizeRequiredInput {
     /** This id generator is only necessary if you want to retrieve a dataflow from the parsed R AST, it determines the id generator to use and by default uses the {@link deterministicCountingIdGenerator}*/
     readonly getId?: IdGenerator<NoInfo>;
 }
 declare function processor(results: {
-    parse?: string;
+    parse?: ParseStepOutput;
 }, input: Partial<NormalizeRequiredInput>): import("../../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
 export declare const NORMALIZE: {
     readonly name: "normalize";

package/core/steps/all/core/20-dataflow.d.ts

@@ -3,14 +3,14 @@ import { PipelineStepStage } from '../../pipeline-step';
 import { dataflowGraphToJson, dataflowGraphToMermaid, dataflowGraphToMermaidUrl, dataflowGraphToQuads } from '../../../print/dataflow-printer';
 import type { NormalizedAst } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RParseRequests } from '../../../../r-bridge/retriever';
-declare function legacyProcessor(results: {
+declare function processor(results: {
     normalize?: NormalizedAst;
 }, input: {
     request?: RParseRequests;
 }): import("../../../../dataflow/info").DataflowInformation;
 export declare const STATIC_DATAFLOW: {
     readonly humanReadableName: "dataflow";
-    readonly processor: typeof legacyProcessor;
+    readonly processor: typeof processor;
     readonly requiredInput: {};
     readonly name: "dataflow";
     readonly description: "Construct the dataflow graph";

package/core/steps/all/core/20-dataflow.js

@@ -17,13 +17,13 @@ const staticDataflowCommon = {
     },
     dependencies: ['normalize'],
 };
-function legacyProcessor(results, input) {
+function processor(results, input) {
     return (0, extractor_1.produceDataFlowGraph)(input.request, results.normalize);
 }
 exports.STATIC_DATAFLOW = {
     ...staticDataflowCommon,
     humanReadableName: 'dataflow',
-    processor: legacyProcessor,
+    processor,
     requiredInput: {}
 };
 //# sourceMappingURL=20-dataflow.js.map

package/core/steps/pipeline/default-pipelines.d.ts

@@ -2,12 +2,15 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
-    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<string>;
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<import("../all/core/00-parse").ParseStepOutput>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
-        readonly 2: (text: string) => string;
-        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+        readonly 2: {
+            (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+            (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+        };
+        readonly 5: ({ parsed }: import("../all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
@@ -16,7 +19,7 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string;
+        parse?: import("../all/core/00-parse").ParseStepOutput;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -80,12 +83,15 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
-    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<string>;
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<import("../all/core/00-parse").ParseStepOutput>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
-        readonly 2: (text: string) => string;
-        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+        readonly 2: {
+            (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+            (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+        };
+        readonly 5: ({ parsed }: import("../all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
@@ -94,7 +100,7 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string;
+        parse?: import("../all/core/00-parse").ParseStepOutput;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -158,12 +164,15 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
-    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<string>;
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<import("../all/core/00-parse").ParseStepOutput>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
-        readonly 2: (text: string) => string;
-        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+        readonly 2: {
+            (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+            (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+        };
+        readonly 5: ({ parsed }: import("../all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
@@ -172,7 +181,7 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string;
+        parse?: import("../all/core/00-parse").ParseStepOutput;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -222,12 +231,15 @@ export declare const DEFAULT_DATAFLOW_PIPELINE: import("./pipeline").Pipeline<{
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
-    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<string>;
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<import("../all/core/00-parse").ParseStepOutput>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
-        readonly 2: (text: string) => string;
-        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+        readonly 2: {
+            (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+            (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+        };
+        readonly 5: ({ parsed }: import("../all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
@@ -236,7 +248,7 @@ export declare const DEFAULT_DATAFLOW_PIPELINE: import("./pipeline").Pipeline<{
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string;
+        parse?: import("../all/core/00-parse").ParseStepOutput;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -272,12 +284,15 @@ export declare const DEFAULT_NORMALIZE_PIPELINE: import("./pipeline").Pipeline<{
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
-    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<string>;
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<import("../all/core/00-parse").ParseStepOutput>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
-        readonly 2: (text: string) => string;
-        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+        readonly 2: {
+            (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+            (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+        };
+        readonly 5: ({ parsed }: import("../all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
@@ -286,7 +301,7 @@ export declare const DEFAULT_NORMALIZE_PIPELINE: import("./pipeline").Pipeline<{
     readonly humanReadableName: "normalize";
     readonly description: "Normalize the AST to flowR's AST";
     readonly processor: (results: {
-        parse?: string;
+        parse?: import("../all/core/00-parse").ParseStepOutput;
     }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
@@ -303,12 +318,15 @@ export declare const DEFAULT_PARSE_PIPELINE: import("./pipeline").Pipeline<{
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
-    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<string>;
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => Promise<import("../all/core/00-parse").ParseStepOutput>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
-        readonly 2: (text: string) => string;
-        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+        readonly 2: {
+            (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+            (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+        };
+        readonly 5: ({ parsed }: import("../all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;

package/core/steps/pipeline/pipeline.d.ts

@@ -23,10 +23,22 @@ export interface Pipeline<T extends IPipelineStep = IPipelineStep> {
  */
 export type PipelineStepNames<P extends Pipeline> = PipelineStep<P>['name'];
 export type PipelineStep<P extends Pipeline> = P extends Pipeline<infer U> ? U : never;
+/**
+ * Meta-information attached to every step result
+ */
+export interface PipelinePerStepMetaInformation {
+    readonly '.meta': {
+        /**
+         * The time it took to execute the step in milliseconds,
+         * the required accuracy is dependent on the measuring system, but usually at around 1 ms.
+         */
+        readonly timing: number;
+    };
+}
 export type PipelineStepWithName<P extends Pipeline, Name extends PipelineStepName> = P extends Pipeline<infer U> ? U extends IPipelineStep<Name> ? U : never : never;
 export type PipelineStepProcessorWithName<P extends Pipeline, Name extends PipelineStepName> = PipelineStepWithName<P, Name>['processor'];
 export type PipelineStepPrintersWithName<P extends Pipeline, Name extends PipelineStepName> = PipelineStepWithName<P, Name>['printer'];
-export type PipelineStepOutputWithName<P extends Pipeline, Name extends PipelineStepName> = Awaited<ReturnType<PipelineStepProcessorWithName<P, Name>>>;
+export type PipelineStepOutputWithName<P extends Pipeline, Name extends PipelineStepName> = Awaited<ReturnType<PipelineStepProcessorWithName<P, Name>>> & PipelinePerStepMetaInformation;
 export type PipelineInput<P extends Pipeline> = UnionToIntersection<PipelineStep<P>['requiredInput']>;
 /**
  * Only gets the union of 'requiredInput' of those PipelineSteps which have a 'execute' field of type 'OncePerRequest'.
@@ -40,8 +52,8 @@ export type PipelineOutput<P extends Pipeline> = {
 };
 /**
  * Creates a {@link Pipeline|pipeline} from a given collection of {@link IPipelineStep|steps}.
- * In order to be valid, the collection of {@link IPipelineStep|steps} must satisfy the following set of constraints
- * (which should be logical, when you consider what a pipeline should accomplish):
+ * To be valid, the collection of {@link IPipelineStep|steps} must satisfy the following set of constraints
+ * (which should be logical, when you consider what a pipeline should achieve):
  *
  * 0) the collection of {@link IPipelineStep|steps} is not empty
  * 1) all {@link IPipelineStepOrder#name|names} of {@link IPipelineStep|steps} are unique for the given pipeline

package/core/steps/pipeline/pipeline.js

@@ -4,8 +4,8 @@ exports.createPipeline = createPipeline;
 const create_pipeline_1 = require("./create-pipeline");
 /**
  * Creates a {@link Pipeline|pipeline} from a given collection of {@link IPipelineStep|steps}.
- * In order to be valid, the collection of {@link IPipelineStep|steps} must satisfy the following set of constraints
- * (which should be logical, when you consider what a pipeline should accomplish):
+ * To be valid, the collection of {@link IPipelineStep|steps} must satisfy the following set of constraints
+ * (which should be logical, when you consider what a pipeline should achieve):
  *
  * 0) the collection of {@link IPipelineStep|steps} is not empty
  * 1) all {@link IPipelineStepOrder#name|names} of {@link IPipelineStep|steps} are unique for the given pipeline

package/dataflow/environments/built-in.d.ts

@@ -23,6 +23,7 @@ import { processLibrary } from '../internal/process/functions/call/built-in/buil
 import { processSourceCall } from '../internal/process/functions/call/built-in/built-in-source';
 import type { ForceArguments } from '../internal/process/functions/call/common';
 import { processApply } from '../internal/process/functions/call/built-in/built-in-apply';
+import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
 export declare const BuiltIn = "built-in";
 export type BuiltInIdentifierProcessor = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>) => DataflowInformation;
 export type BuiltInIdentifierProcessorWithConfig<Config> = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: Config) => DataflowInformation;
@@ -36,12 +37,13 @@ export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierRefere
     definedAt: typeof BuiltIn;
     value: T;
 }
-declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
-    returnsNthArgument?: number | 'last';
-    cfg?: ExitPointType;
-    readAllArguments?: boolean;
-    hasUnknownSideEffects?: boolean;
-} & ForceArguments): DataflowInformation;
+export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
+    readonly returnsNthArgument?: number | 'last';
+    readonly cfg?: ExitPointType;
+    readonly readAllArguments?: boolean;
+    readonly hasUnknownSideEffects?: boolean | LinkTo<RegExp | string>;
+}
+declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: DefaultBuiltInProcessorConfiguration): DataflowInformation;
 export declare function registerBuiltInFunctions<Config, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
 export declare const BuiltInProcessorMapper: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;

package/dataflow/environments/built-in.js

@@ -41,7 +41,12 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
         }
     }
     if (config.hasUnknownSideEffects) {
-        res.graph.markIdForUnknownSideEffects(rootId);
+        if (typeof config.hasUnknownSideEffects !== 'boolean') {
+            res.graph.markIdForUnknownSideEffects(rootId, config.hasUnknownSideEffects);
+        }
+        else {
+            res.graph.markIdForUnknownSideEffects(rootId);
+        }
     }
     if (config.cfg !== undefined) {
         res.exitPoints = [...res.exitPoints, { type: config.cfg, nodeId: rootId, controlDependencies: data.controlDependencies }];

package/dataflow/environments/default-builtin-config.js

@@ -11,12 +11,22 @@ exports.DefaultBuiltinConfig = [
     {
         type: 'function',
         names: [
-            '~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list', 'c',
+            '~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list',
             'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max',
             'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean',
-            'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'plot', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
+            'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
             'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor',
-            'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar', 't'
+            'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar',
+            'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz'
+        ],
+        processor: 'builtin:default',
+        config: { readAllArguments: true },
+        assumePrimitive: true
+    },
+    {
+        type: 'function',
+        names: [
+            'c', 't'
         ],
         processor: 'builtin:default',
         config: { readAllArguments: true },
@@ -27,11 +37,17 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
     { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
     { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: 'builtin:apply', config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['print'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all' }, assumePrimitive: false },
+    { type: 'function', names: ['print', 'message', 'warning'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
+    // graphics base
+    { type: 'function', names: ['plot', 'plot.new', 'curve', 'map', 'image', 'boxplot', 'dotchart', 'sunflowerplot', 'barplot', 'matplot', 'hist', 'stem', 'density', 'smoothScatter', 'contour', 'persp'],
+        processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^pdf|jpeg|png|windows|postscript|xfig|bitmap|pictex|cairo_pdf|svg|bmp|tiff|X11|quartz$/ } }, assumePrimitive: true },
+    // graphics addons
+    { type: 'function', names: ['points', 'abline', 'mtext', 'lines', 'text', 'legend', 'title', 'axis', 'polygon', 'polypath', 'pie', 'rect', 'segments', 'arrows', 'symbols', 'tiplabels'],
+        processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^dev\.new|dev\.copy|plot\.new|xspline|sunflowerplot|dotchart|plot|map|image|curve|boxplot|barplot|matplot|hist|stem|density|smoothScatter|contour|persp$/ } }, assumePrimitive: true },
     { type: 'function', names: ['('], processor: 'builtin:default', config: { returnsNthArgument: 0 }, assumePrimitive: true },
     { type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
     { type: 'function', names: ['eval', 'body', 'formals', 'environment'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
-    { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all' }, assumePrimitive: false },
+    { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },
     { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ }, assumePrimitive: false },
     { type: 'function', names: ['break'], processor: 'builtin:default', config: { cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },