reverseport 0.0.0-stage → 1.2.0

package/dist/domain/javascript/javascriptSemanticDataEffects.js

@@ -0,0 +1,299 @@
+import * as t from "@babel/types";
+import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
+/** Recover configuration, request, and boundary candidates from inert syntax. */
+export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
+    const context = {
+        state,
+        callableIds: new Set(callables.map(({ callableId }) => callableId)),
+        callableStack: [],
+        ancestors: [],
+    };
+    const configuration = collectConfigurations(program, context);
+    const requests = collectRequests(program, context);
+    return {
+        configurationOperations: [
+            ...configuration.map(({ operation }) => operation),
+            ...collectDefaults(program, context, configuration),
+        ],
+        requestOperations: [
+            ...requests.map(({ operation }) => operation),
+            ...collectResponseConsumers(program, context, requests),
+        ],
+        boundaryOperations: collectBoundaries(program, context),
+    };
+};
+const collectConfigurations = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node, parent) => {
+        const details = configurationDetails(node, parent, context);
+        if (details === null)
+            return;
+        const operation = {
+            configId: `config:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: details.kind,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            key: details.key,
+            sourceConfigId: null,
+            value: null,
+            resolution: details.resolution,
+        };
+        output.push({ node, operation });
+    });
+    return output;
+};
+const configurationDetails = (node, parent, context) => {
+    if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
+        !(memberObject(parent) === node)) {
+        const processMember = processConfigurationMember(node, context.state);
+        if (processMember !== null)
+            return processMember;
+    }
+    if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+        return null;
+    const fileMethod = builtinMethod(node.callee, context.state, [
+        "fs",
+        "node:fs",
+    ]);
+    return fileMethod === "readFile" || fileMethod === "readFileSync"
+        ? {
+            kind: "file",
+            key: literalString(node.arguments[0]),
+            resolution: literalString(node.arguments[0]) === null ? "partial" : "complete",
+        }
+        : null;
+};
+const processConfigurationMember = (node, state) => {
+    const object = node.object;
+    if (!t.isMemberExpression(object) && !t.isOptionalMemberExpression(object))
+        return null;
+    if (!isProcessObject(object.object, state))
+        return null;
+    const family = semanticStaticPropertyName(object.property, object.computed);
+    if (family !== "env" && family !== "argv")
+        return null;
+    // `process.env[""]` names an exact (empty) key; only a dynamic key is unknown.
+    const key = semanticStaticPropertyKey(node.property, node.computed);
+    if (family === "argv" && key !== null && !isArrayIndexKey(key))
+        return null;
+    return {
+        kind: family === "env" ? "environment" : "argv",
+        key,
+        resolution: key === null ? "partial" : "complete",
+    };
+};
+const isArrayIndexKey = (key) => {
+    if (!/^(?:0|[1-9][0-9]*)$/u.test(key))
+        return false;
+    const index = Number(key);
+    return Number.isSafeInteger(index) && index < 2 ** 32 - 1;
+};
+const collectDefaults = (program, context, configurations) => {
+    const output = [];
+    const configurationsByNode = new Map(configurations.map((candidate) => [candidate.node, candidate]));
+    traverseWithContext(program, context, (node) => {
+        if (!t.isLogicalExpression(node) ||
+            (node.operator !== "??" && node.operator !== "||"))
+            return;
+        const source = unwrapJavaScriptExpression(node.left).node;
+        const candidate = configurationsByNode.get(source);
+        if (candidate === undefined)
+            return;
+        output.push({
+            configId: `config:default:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: "default",
+            location: range(node.right),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            key: candidate.operation.key,
+            sourceConfigId: candidate.operation.configId,
+            value: primitiveValue(node.right),
+            resolution: primitiveValue(node.right) === null ? "partial" : "complete",
+        });
+    });
+    return output;
+};
+const collectRequests = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) &&
+            !t.isOptionalCallExpression(node) &&
+            !t.isNewExpression(node))
+            return;
+        const method = requestMethod(node, context.state);
+        if (method === null)
+            return;
+        const endpoint = requestEndpoint(node);
+        output.push({
+            node,
+            operation: {
+                requestId: `request:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+                kind: "request",
+                method,
+                location: range(node),
+                ownerCallableId: context.callableStack.at(-1) ?? null,
+                resultBindingId: outerAssignedBinding(node, context),
+                projectedResultBindings: semanticProjectedBindingFacts(assignedSemanticResultBindings(node, context.ancestors, context.state).filter(({ projectionPath }) => projectionPath.length > 0)),
+                linkedRequestIds: [],
+                endpoint,
+                fields: requestFields(node, method, context.state),
+                resolution: endpoint === null ? "partial" : "complete",
+            },
+        });
+    });
+    return output;
+};
+const collectResponseConsumers = (program, context, requests) => {
+    const requestsByBinding = new Map();
+    for (const request of requests) {
+        const bindingIds = [
+            ...(request.operation.resultBindingId === null
+                ? []
+                : [request.operation.resultBindingId]),
+            ...request.operation.projectedResultBindings.map(({ bindingId }) => bindingId),
+        ];
+        for (const bindingId of bindingIds) {
+            const existing = requestsByBinding.get(bindingId) ?? [];
+            existing.push(request);
+            requestsByBinding.set(bindingId, existing);
+        }
+    }
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+            return;
+        const member = memberCallee(node);
+        if (member === null || !t.isIdentifier(member.object))
+            return;
+        const method = semanticStaticPropertyName(member.property, member.computed);
+        if (method !== "json" && method !== "text" && method !== "arrayBuffer")
+            return;
+        const binding = resolveSemanticBindingState(context.state, member.object, member.object.name);
+        const linked = binding === undefined
+            ? []
+            : (requestsByBinding.get(binding.bindingId) ?? []);
+        if (linked.length === 0)
+            return;
+        output.push({
+            requestId: `response:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: "response-consumer",
+            method,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            projectedResultBindings: semanticProjectedBindingFacts(assignedSemanticResultBindings(node, context.ancestors, context.state).filter(({ projectionPath }) => projectionPath.length > 0)),
+            linkedRequestIds: linked
+                .map(({ operation }) => operation.requestId)
+                .sort(compareUnicodeCodePoints),
+            endpoint: null,
+            fields: [],
+            resolution: linked.length === 1 &&
+                !linked[0]?.operation.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
+                ? "complete"
+                : "partial",
+        });
+    });
+    return output;
+};
+const collectBoundaries = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+            return;
+        const details = boundaryDetails(node, context.state);
+        if (details === null)
+            return;
+        output.push({
+            boundaryId: `boundary:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: details.kind,
+            method: details.method,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            sourceBindingId: argumentBindingId(node.arguments[0], context.state),
+            resultBindingId: outerAssignedBinding(node, context),
+            resolution: details.resolution,
+        });
+    });
+    return output;
+};
+const boundaryDetails = (node, state) => {
+    if (t.isIdentifier(node.callee)) {
+        const name = node.callee.name;
+        const unbound = resolveSemanticBindingState(state, node.callee, name) === undefined &&
+            !semanticResolutionBlocked(state, node.callee, name);
+        if (unbound &&
+            ["String", "Number", "Boolean", "parseInt", "parseFloat"].includes(name))
+            return { kind: "coerce", method: name, resolution: "complete" };
+    }
+    const member = memberCallee(node);
+    if (member === null)
+        return null;
+    const method = semanticStaticPropertyName(member.property, member.computed);
+    if (method === "parse" &&
+        t.isIdentifier(member.object, { name: "JSON" }) &&
+        resolveSemanticBindingState(state, member.object, "JSON") === undefined &&
+        !semanticResolutionBlocked(state, member.object, "JSON"))
+        return { kind: "parse", method: "JSON.parse", resolution: "complete" };
+    if (method === "parse" || method === "safeParse")
+        return { kind: "parse", method, resolution: "partial" };
+    if (method === "validate" || method === "assert" || method === "is")
+        return { kind: "validate", method, resolution: "partial" };
+    return null;
+};
+const requestMethod = (node, state) => {
+    if (t.isIdentifier(node.callee)) {
+        const name = node.callee.name;
+        const unbound = resolveSemanticBindingState(state, node.callee, name) === undefined &&
+            !semanticResolutionBlocked(state, node.callee, name);
+        if (!t.isNewExpression(node) && unbound && name === "fetch")
+            return "fetch";
+        if (t.isNewExpression(node) && unbound && name === "WebSocket")
+            return "WebSocket";
+    }
+    const member = memberCallee(node);
+    if (member === null || !t.isIdentifier(member.object))
+        return null;
+    const method = semanticStaticPropertyName(member.property, member.computed);
+    if (method !== "request" && method !== "get")
+        return null;
+    const binding = resolveSemanticBindingState(state, member.object, member.object.name);
+    return binding?.directOrigins.some(({ specifier, importedPath }) => ["http", "https", "node:http", "node:https"].includes(specifier) &&
+        semanticBuiltinNamespacePath(importedPath))
+        ? method
+        : null;
+};
+const requestFields = (node, method, state) => {
+    const candidate = method === "fetch" || method === "WebSocket"
+        ? node.arguments[1]
+        : t.isObjectExpression(node.arguments[0])
+            ? node.arguments[0]
+            : node.arguments[1];
+    if (!t.isObjectExpression(candidate))
+        return [];
+    return candidate.properties.flatMap((property) => {
+        if (!t.isObjectProperty(property))
+            return [];
+        // `{[key]: 1}` sends no knowable field name; reporting `key` would invent
+        // a request field that may not exist.
+        const name = semanticStaticPropertyKey(property.key, property.computed);
+        if (name === null)
+            return [];
+        return [
+            {
+                name,
+                sourceBindingId: t.isIdentifier(property.value)
+                    ? (resolveSemanticBindingState(state, property.value, property.value.name)?.bindingId ?? null)
+                    : null,
+            },
+        ];
+    });
+};
+const requestEndpoint = (node) => t.isObjectExpression(node.arguments[0])
+    ? null
+    : literalString(node.arguments[0]);

package/dist/domain/javascript/javascriptSemanticDerivedAnalysis.js

@@ -0,0 +1,52 @@
+import { collectJavaScriptSemanticAsyncEffects } from "./javascriptSemanticAsyncEffects.js";
+import { collectJavaScriptSemanticCalls } from "./javascriptSemanticCalls.js";
+import { collectJavaScriptSemanticChildProcesses } from "./javascriptSemanticChildProcesses.js";
+import { collectJavaScriptSemanticFingerprintsSteps } from "./javascriptSemanticFingerprints.js";
+import { collectJavaScriptSemanticDataEffects } from "./javascriptSemanticDataEffects.js";
+import { collectJavaScriptSemanticPromises } from "./javascriptSemanticPromises.js";
+import { collectJavaScriptSemanticObjects } from "./javascriptSemanticObjects.js";
+import { collectJavaScriptSemanticResources } from "./javascriptSemanticResources.js";
+/** Compose bounded semantic passes after lexical definitions are available. */
+/**
+ * Collect derived semantics with a yield between collectors. Each collector
+ * completes before the next starts, so results equal the synchronous form.
+ */
+export function* collectJavaScriptDerivedSemanticsSteps(program, state, callables, parserPartial) {
+    const calls = collectJavaScriptSemanticCalls(program, state, callables);
+    yield;
+    const promiseOperations = collectJavaScriptSemanticPromises(program, state, callables);
+    yield;
+    const asyncEffects = collectJavaScriptSemanticAsyncEffects(program, state, callables);
+    yield;
+    const childProcesses = collectJavaScriptSemanticChildProcesses(program, state, callables);
+    yield;
+    const dataEffects = collectJavaScriptSemanticDataEffects(program, state, callables);
+    yield;
+    const resourceOperations = collectJavaScriptSemanticResources(program, state, callables);
+    yield;
+    const objectOperations = collectJavaScriptSemanticObjects(program, state, callables);
+    yield;
+    const functionFingerprints = yield* collectJavaScriptSemanticFingerprintsSteps({
+        state,
+        callables,
+        calls,
+        promises: promiseOperations,
+        events: asyncEffects.eventOperations,
+        timers: asyncEffects.timerOperations,
+        childProcessSpawns: childProcesses.childProcessSpawns,
+        childProcessInteractions: childProcesses.childProcessInteractions,
+        requestOperations: dataEffects.requestOperations,
+        resourceOperations,
+        parserPartial,
+    });
+    return {
+        ...calls,
+        promiseOperations,
+        ...asyncEffects,
+        ...childProcesses,
+        ...dataEffects,
+        resourceOperations,
+        objectOperations,
+        functionFingerprints,
+    };
+}

package/dist/domain/javascript/javascriptSemanticFileProjection.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/javascript/javascriptSemanticFingerprints.js

@@ -0,0 +1,187 @@
+import { createHash } from "node:crypto";
+import * as t from "@babel/types";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";
+/** Build bounded rename- and formatting-resistant components per callable, yielding between callables. */
+export function* collectJavaScriptSemanticFingerprintsSteps(input) {
+    const { state, callables, calls, promises, events, timers, childProcessSpawns, childProcessInteractions, requestOperations, resourceOperations, parserPartial, } = input;
+    const callSitesByCaller = groupByOwner(calls.callSites, ({ callerCallableId }) => callerCallableId);
+    const captureCountByCallable = countByOwner(calls.closureCaptures, ({ callableId }) => callableId);
+    const promiseEffectsByOwner = groupByOwner(promises, ownerId);
+    const eventEffectsByOwner = groupByOwner(events, ownerId);
+    const timerEffectsByOwner = groupByOwner(timers, ownerId);
+    const childProcessEffectsByOwner = groupByOwner([...childProcessSpawns, ...childProcessInteractions], ownerId);
+    const networkEffectsByOwner = groupByOwner(requestOperations, ownerId);
+    const resourceEffectsByOwner = groupByOwner(resourceOperations, ownerId);
+    const fingerprints = [];
+    for (const callable of callables) {
+        if (callable.kind === "class")
+            continue;
+        const node = state.callableNodesById.get(callable.callableId);
+        if (node === undefined)
+            continue;
+        yield;
+        const syntax = yield* fingerprintSyntaxSteps(node);
+        const promiseEffects = promiseEffectsByOwner.get(callable.callableId) ?? [];
+        const eventEffects = eventEffectsByOwner.get(callable.callableId) ?? [];
+        const timerEffects = timerEffectsByOwner.get(callable.callableId) ?? [];
+        const childProcessEffects = childProcessEffectsByOwner.get(callable.callableId) ?? [];
+        const networkEffects = networkEffectsByOwner.get(callable.callableId) ?? [];
+        const resourceEffects = resourceEffectsByOwner.get(callable.callableId) ?? [];
+        fingerprints.push({
+            callableId: callable.callableId,
+            status: parserPartial || callable.returnCoverage.status !== "complete"
+                ? "partial"
+                : "complete",
+            components: {
+                parameterArity: callableParameterArity(node),
+                normalizedAstSha256: digest(syntax.normalizedTokens),
+                controlFlowSha256: digest(syntax.controlFlowTokens),
+                relationShapeSha256: digest(relationShape(callable, callSitesByCaller.get(callable.callableId) ?? [], captureCountByCallable.get(callable.callableId) ?? 0, promiseEffects)),
+                literalSetSha256: digest([...new Set(syntax.literals)].sort(compareUnicodeCodePoints)),
+                effects: [
+                    ...(isAsyncCallable(node) ? ["async"] : []),
+                    ...(childProcessEffects.length > 0
+                        ? ["child-process"]
+                        : []),
+                    ...(eventEffects.length > 0 ? ["event"] : []),
+                    ...(networkEffects.length > 0 ? ["network"] : []),
+                    ...(promiseEffects.length > 0 ? ["promise"] : []),
+                    ...(resourceEffects.length > 0 ? ["resource"] : []),
+                    ...(timerEffects.length > 0 ? ["timer"] : []),
+                ],
+            },
+            limitations: [
+                "The fingerprint is a static candidate and does not prove behavioral equivalence.",
+                ...(parserPartial
+                    ? ["Incomplete semantic recovery makes this fingerprint partial."]
+                    : []),
+            ],
+        });
+    }
+    return fingerprints;
+}
+const ownerId = (value) => value.ownerCallableId;
+const groupByOwner = (values, getOwner) => {
+    const grouped = new Map();
+    for (const value of values) {
+        const owner = getOwner(value);
+        const ownedValues = grouped.get(owner);
+        if (ownedValues === undefined)
+            grouped.set(owner, [value]);
+        else
+            ownedValues.push(value);
+    }
+    return grouped;
+};
+const countByOwner = (values, getOwner) => {
+    const counts = new Map();
+    for (const value of values) {
+        const owner = getOwner(value);
+        counts.set(owner, (counts.get(owner) ?? 0) + 1);
+    }
+    return counts;
+};
+function* fingerprintSyntaxSteps(root) {
+    const normalizedTokens = [];
+    const controlFlowTokens = [];
+    const literals = [];
+    yield* traverseJavaScriptAstSteps(root, {
+        skip: (node) => semanticCallableIdForNode(node) !== null,
+        enter: (node, parent) => {
+            normalizedTokens.push(normalizedNodeToken(node, parent));
+            const control = controlFlowToken(node);
+            if (control !== null)
+                controlFlowTokens.push(control);
+            const literal = semanticLiteral(node);
+            if (literal !== null)
+                literals.push(literal);
+        },
+    });
+    return { normalizedTokens, controlFlowTokens, literals };
+}
+const normalizedNodeToken = (node, parent) => {
+    if (t.isIdentifier(node))
+        return propertyIdentity(node, parent)
+            ? `property:${node.name}`
+            : "identifier";
+    if (t.isStringLiteral(node))
+        return propertyIdentity(node, parent)
+            ? `property:${node.value}`
+            : "string-literal";
+    const attributes = [
+        primitiveAttribute(node, "operator"),
+        primitiveAttribute(node, "kind"),
+        primitiveAttribute(node, "computed"),
+        primitiveAttribute(node, "optional"),
+        primitiveAttribute(node, "async"),
+        primitiveAttribute(node, "generator"),
+    ].filter((value) => value !== null);
+    return [node.type, ...attributes].join(":");
+};
+const primitiveAttribute = (node, key) => {
+    const value = Reflect.get(node, key);
+    return typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+        ? `${key}=${String(value)}`
+        : null;
+};
+const propertyIdentity = (node, parent) => {
+    if (parent === null)
+        return false;
+    if ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&
+        parent.property === node)
+        return !parent.computed || t.isStringLiteral(node);
+    if ((t.isObjectProperty(parent) ||
+        t.isObjectMethod(parent) ||
+        t.isClassMethod(parent) ||
+        t.isClassProperty(parent)) &&
+        parent.key === node)
+        return !parent.computed || t.isStringLiteral(node);
+    return false;
+};
+const controlFlowToken = (node) => {
+    if (!t.isIfStatement(node) &&
+        !t.isConditionalExpression(node) &&
+        !t.isSwitchStatement(node) &&
+        !t.isSwitchCase(node) &&
+        !t.isLoop(node) &&
+        !t.isTryStatement(node) &&
+        !t.isCatchClause(node) &&
+        !t.isReturnStatement(node) &&
+        !t.isThrowStatement(node) &&
+        !t.isAwaitExpression(node) &&
+        !t.isYieldExpression(node) &&
+        !t.isLogicalExpression(node))
+        return null;
+    const operator = primitiveAttribute(node, "operator");
+    return operator === null ? node.type : `${node.type}:${operator}`;
+};
+const semanticLiteral = (node) => {
+    if (t.isStringLiteral(node))
+        return `string:${node.value}`;
+    if (t.isNumericLiteral(node))
+        return `number:${String(node.value)}`;
+    if (t.isBooleanLiteral(node))
+        return `boolean:${String(node.value)}`;
+    if (t.isNullLiteral(node))
+        return "null";
+    if (t.isBigIntLiteral(node))
+        return `bigint:${node.value}`;
+    if (t.isRegExpLiteral(node))
+        return `regexp:${node.pattern}/${node.flags}`;
+    if (t.isTemplateElement(node))
+        return `template:${node.value.cooked ?? node.value.raw}`;
+    return null;
+};
+const relationShape = (callable, callSites, captureCount, promises) => [
+    `returns:${String(callable.returnSites.length)}:${callable.returnCoverage.status}`,
+    ...callSites.map(({ kind, resolution, arguments: args, calleeCallableIds }) => `call:${kind}:${resolution}:${String(args.length)}:${String(calleeCallableIds.length)}`),
+    `captures:${String(captureCount)}`,
+    ...promises.map(({ kind, method, ownership, sourceResolution }) => `promise:${kind}:${method}:${ownership}:${sourceResolution}`),
+];
+const callableParameterArity = (node) => t.isFunction(node) ? node.params.length : 0;
+const isAsyncCallable = (node) => t.isFunction(node) && node.async;
+const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");