reverseport 0.0.0-stage → 1.2.0

package/dist/domain/javascript/javascriptNativeHandoff.js

@@ -0,0 +1,90 @@
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+/** Build provider-neutral addon targets and link exact-subject native Evidence. */
+export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {
+    const nodeById = new Map(nodes.map((node) => [node.node_id, node]));
+    return nodes
+        .filter(({ kind }) => kind === "native-addon")
+        .flatMap((node) => {
+        const digest = artifactDigest(node);
+        if (digest === null)
+            return [];
+        const linked = nativeEvidence.filter(({ subject }) => subject?.digest.sha256 === digest);
+        const exportNodes = nativeExportNodes(node, edges, nodeById);
+        return [
+            {
+                native_node_id: node.node_id,
+                artifact_sha256: digest,
+                artifact_path: artifactPath(node),
+                export_node_ids: exportNodes.map(({ node_id: id }) => id),
+                requested_exports: requestedExports(exportNodes),
+                status: linked.length === 0
+                    ? "requires-provider-analysis"
+                    : "evidence-linked",
+                providers: uniqueProviders(linked),
+                evidence_ids: linked
+                    .map(({ evidence_id: id }) => id)
+                    .sort(compareUnicodeCodePoints),
+                recommended_tools: [
+                    "open_binary",
+                    "binary_overview",
+                    "search_procedures",
+                    "analyze_function",
+                    "xrefs",
+                ],
+            },
+        ];
+    })
+        .sort((left, right) => compareUnicodeCodePoints(left.native_node_id, right.native_node_id));
+};
+const artifactDigest = (node) => {
+    if (node.identity.strategy === "content-digest")
+        return node.identity.sha256;
+    const observation = node.observations.find(({ evidence }) => evidence.artifact.available);
+    return observation?.evidence.artifact.available === true
+        ? observation.evidence.artifact.sha256
+        : null;
+};
+const artifactPath = (node) => {
+    for (const { evidence } of node.observations)
+        if (evidence.location.available &&
+            evidence.location.value.kind === "artifact-path")
+            return evidence.location.value.path;
+    return null;
+};
+const nativeExportNodes = (addon, edges, nodeById) => {
+    const ids = edges.flatMap((edge) => {
+        if (edge.source_node_id === addon.node_id &&
+            ["contains", "exposes"].includes(edge.relation))
+            return [edge.target_node_id];
+        if (edge.target_node_id === addon.node_id &&
+            ["imports", "loads"].includes(edge.relation))
+            return [edge.source_node_id];
+        return [];
+    });
+    return [...new Set(ids)]
+        .map((id) => nodeById.get(id))
+        .filter((node) => node?.kind === "native-export")
+        .sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id));
+};
+const requestedExports = (nodes) => {
+    const values = nodes.flatMap((node) => node.observations.flatMap((observation) => [
+        // Display labels can summarize several names or namespace access.
+        // Only legacy observations without structured member facts need them.
+        ...(observation.label === null ||
+            Array.isArray(observation.properties.requested_members)
+            ? []
+            : [observation.label]),
+        ...stringArray(observation.properties.requested_members),
+        ...stringArray(observation.properties.members),
+    ]));
+    return [...new Set(values)].sort(compareUnicodeCodePoints);
+};
+const stringArray = (value) => Array.isArray(value)
+    ? value.filter((item) => typeof item === "string")
+    : [];
+const uniqueProviders = (evidence) => [
+    ...new Map(evidence.map(({ provider }) => [
+        `${provider.id}\0${provider.name}\0${provider.version ?? ""}`,
+        provider,
+    ])).values(),
+].sort((left, right) => compareUnicodeCodePoints(`${left.id}\0${left.name}\0${left.version ?? ""}`, `${right.id}\0${right.name}\0${right.version ?? ""}`));

package/dist/domain/javascript/javascriptPackageImportAliases.js

@@ -0,0 +1,58 @@
+/**
+ * Exact package-private import-alias lookup. Node resolves `#` specifiers
+ * against the importer's enclosing package `imports` map; this module owns the
+ * specifier and exact-key rules. Condition, array, and null target selection
+ * stay with the shared package-target machinery. Wildcard keys, recursive
+ * `#` targets, and external-package targets remain explicit unknowns.
+ */
+/**
+ * Classify a `#` module specifier before any package-scope walk.
+ * `#` and names ending in `/` are invalid. Other literal keys, including
+ * `#/…`, participate in exact lookup; wildcard expansion remains unsupported.
+ */
+export const classifyPackageImportSpecifier = (specifier) => {
+    if (specifier === "#" || specifier.endsWith("/"))
+        return { kind: "invalid" };
+    if (specifier.includes("*"))
+        return { kind: "pattern" };
+    return { kind: "exact", key: specifier };
+};
+/** True when an `imports` key is a pattern rather than an exact alias. */
+export const isPackageImportPatternKey = (key) => key.includes("*") || key.endsWith("/");
+/**
+ * Look up one exact `#` key in a package `imports` value.
+ * A missing exact key is reported as missing when every declared key is also
+ * exact; if the map contains pattern keys, the miss stays pattern-unresolved
+ * rather than claiming the specifier is undefined.
+ */
+export const lookupExactPackageImport = (imports, key) => {
+    if (typeof imports !== "object" || imports === null || Array.isArray(imports))
+        return { kind: "undefined-map" };
+    const declared = Object.keys(imports);
+    if (Object.hasOwn(imports, key) && !isPackageImportPatternKey(key))
+        return {
+            kind: "found",
+            target: Reflect.get(imports, key),
+            declared,
+        };
+    return declared.some(isPackageImportPatternKey)
+        ? { kind: "pattern-unresolved", declared }
+        : { kind: "missing-key", declared };
+};
+/**
+ * Classify a selected string import target. Only package-local `./` paths are
+ * resolved as files; recursive `#` aliases and bare packages stay unknown.
+ * Parent-relative, absolute, and URL targets are invalid, allowing array
+ * selection to skip them before choosing a package-local fallback.
+ */
+export const classifyPackageImportTargetString = (target) => {
+    if (target.startsWith("./"))
+        return { kind: "relative", target };
+    if (target.startsWith("../") ||
+        target.startsWith("/") ||
+        URL.canParse(target))
+        return { kind: "invalid", target };
+    if (target.startsWith("#"))
+        return { kind: "recursive", target };
+    return { kind: "external-package", target };
+};

package/dist/domain/javascript/javascriptRecovery.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { digestSchema } from "../digests.js";
+import { analyzeJavaScriptApplicationInputSchema } from "./javascriptApplicationAnalysis.js";
+import { localPathStringSchema } from "../localPath.js";
+/** Recover derived readable modules from explicitly selected local scripts. */
+export const javascriptRecoveryInputSchema = z.strictObject({
+    path: localPathStringSchema.describe("Absolute path to a UTF-8 JavaScript file; never executed"),
+    additional_paths: z
+        .array(localPathStringSchema)
+        .max(16)
+        .optional()
+        .describe("Additional absolute UTF-8 JavaScript files recovered together with path; each is snapshotted separately so imports can resolve across related chunks. All inputs share a 64 MiB total budget"),
+    output_directory: localPathStringSchema.describe("Absolute absent output directory; parent must exist"),
+    extraction_mode: z
+        .enum(["structural", "heuristic", "inspection"])
+        .default("structural")
+        .describe("Structural module boundaries, heuristic fallback, or finer inspection-only regions"),
+    rewrite_level: z
+        .enum(["minimal", "standard", "aggressive"])
+        .default("standard")
+        .describe("Upstream syntax recovery level; runtime equivalence remains unverified"),
+});
+const fileSchema = z.strictObject({
+    path: z.string().min(1),
+    sha256: digestSchema,
+    bytes: z.number().int().nonnegative(),
+});
+const rangeSchema = z.strictObject({
+    start: z.number().int().nonnegative(),
+    end: z.number().int().nonnegative(),
+});
+const sourceSchema = fileSchema.extend({
+    snapshot_path: z.string().min(1),
+    published_copy: fileSchema,
+});
+/** Complete published artifacts and exact producer provenance for source recovery. */
+export const javascriptRecoveryResultSchema = z.strictObject({
+    source: sourceSchema,
+    additional_sources: z.array(sourceSchema).optional(),
+    engine: z.strictObject({
+        id: z.string().min(1),
+        version: z.string().min(1),
+        executable: fileSchema,
+        audited_source_revision: z.string().min(1),
+        executed_source_revision: z.string().nullable(),
+    }),
+    options: z.strictObject({
+        extraction_mode: javascriptRecoveryInputSchema.shape.extraction_mode.removeDefault(),
+        rewrite_level: javascriptRecoveryInputSchema.shape.rewrite_level.removeDefault(),
+    }),
+    status: z.enum(["complete", "partial"]),
+    detected_formats: z.array(z.string()),
+    reported_safety: z.string(),
+    reported_strategy: z.string(),
+    reported_format: z.string(),
+    total: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    modules: z.array(z.strictObject({
+        reported_filename: z.string().min(1),
+        reported_status: z.string().min(1),
+        artifact: fileSchema,
+        source_map: fileSchema.nullable(),
+        provenance: z.strictObject({
+            reported_input: z.string(),
+            original_path: z.string(),
+            original_sha256: digestSchema,
+            extraction: z.string(),
+            byte_ranges: z.array(rangeSchema),
+            context_byte_ranges: z.array(rangeSchema),
+            range_semantics: z.literal("half-open-utf8-bytes"),
+        }),
+    })),
+    warnings: z.array(z.strictObject({
+        filename: z.string(),
+        kind: z.string(),
+        is_error: z.boolean(),
+        message: z.string(),
+    })),
+    report: fileSchema,
+    provenance: fileSchema,
+    manifest: fileSchema,
+    analysis_input: z
+        .strictObject({
+        input_path: analyzeJavaScriptApplicationInputSchema.shape.input_path,
+        format: z.literal("directory"),
+    })
+        .nullable(),
+    runtime_equivalence: z.literal("unknown"),
+    limitations: z.array(z.string()),
+});

package/dist/domain/javascript/javascriptRpcEndpoints.js

@@ -0,0 +1,253 @@
+import * as t from "@babel/types";
+import { unwrapJavaScriptExpression, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
+import { calleeName } from "./javascriptStaticAnalysisHelpers.js";
+// tRPC proxies preserve router and procedure names as property names, so they
+// survive identifier minification. Method names follow @trpc/react-query and
+// @trpc/tanstack-react-query 11.19 documentation; cache-key helpers such as
+// queryKey are excluded because they never issue a request.
+const TRPC_HOOK_METHODS = new Set([
+    "useQuery",
+    "useSuspenseQuery",
+    "useInfiniteQuery",
+    "useSuspenseInfiniteQuery",
+    "usePrefetchQuery",
+    "usePrefetchInfiniteQuery",
+    "useMutation",
+    "useSubscription",
+    "queryOptions",
+    "infiniteQueryOptions",
+    "mutationOptions",
+    "subscriptionOptions",
+]);
+// @trpc/client 11.19 clientCallTypeMap methods; common outside tRPC (Apollo,
+// database pools, stores), so they need corroborating evidence.
+const TRPC_REQUEST_METHODS = new Set(["query", "mutate"]);
+// @trpc/client 11.19 TRPCSubscriptionObserver callbacks; RxJS observers use
+// next/error/complete instead.
+const TRPC_SUBSCRIPTION_CALLBACKS = new Set([
+    "onStarted",
+    "onData",
+    "onError",
+    "onStopped",
+    "onComplete",
+    "onConnectionStateChange",
+]);
+// @trpc/client 11.19 client factories (createTRPCProxyClient is the
+// deprecated alias of createTRPCClient).
+const TRPC_CLIENT_FACTORIES = new Set([
+    "createTRPCClient",
+    "createTRPCProxyClient",
+]);
+// Built-in HTTP links documented by tRPC 11.19 that carry a `url` option.
+const TRPC_URL_LINKS = new Set([
+    "httpLink",
+    "httpBatchLink",
+    "httpBatchStreamLink",
+    "httpSubscriptionLink",
+]);
+// Literals retained by @trpc/client 11.19 bundles (`this.name`, the default
+// accept header key) or by the conventional transport path.
+const TRPC_SOURCE_MARKERS = ["TRPCClientError", "trpc-accept", "/trpc"];
+// Browser-owned roots whose methods share tRPC names, such as
+// navigator.permissions.query.
+const BROWSER_GLOBAL_NAMES = new Set([
+    "window",
+    "self",
+    "globalThis",
+    "document",
+    "navigator",
+    "location",
+    "history",
+    "console",
+    "performance",
+    "screen",
+    "top",
+    "parent",
+    "frames",
+]);
+const PROCEDURE_SEGMENT = /^[A-Za-z_$][\w$]*$/u;
+/** Read a static member path and the expression it starts from. */
+const memberPath = (callee) => {
+    const reversed = [];
+    let current = callee;
+    while (t.isMemberExpression(current) ||
+        t.isOptionalMemberExpression(current)) {
+        const property = semanticStaticPropertyKey(current.property, current.computed);
+        if (property === null || !PROCEDURE_SEGMENT.test(property))
+            return undefined;
+        reversed.push(property);
+        current = current.object;
+    }
+    return { root: current, properties: reversed.reverse() };
+};
+const objectKeys = (node) => t.isObjectExpression(node)
+    ? node.properties.flatMap((property) => {
+        if (!t.isObjectProperty(property) && !t.isObjectMethod(property))
+            return [];
+        const key = semanticStaticPropertyKey(property.key, property.computed);
+        return key === null ? [] : [key];
+    })
+    : [];
+const objectStringProperty = (node, key) => {
+    for (const property of node.properties)
+        if (t.isObjectProperty(property) &&
+            semanticStaticPropertyKey(property.key, property.computed) === key &&
+            t.isStringLiteral(property.value))
+            return property.value.value;
+    return undefined;
+};
+const objectProperty = (node, key) => {
+    for (const property of node.properties)
+        if (t.isObjectProperty(property) &&
+            semanticStaticPropertyKey(property.key, property.computed) === key)
+            return property.value;
+    return undefined;
+};
+const GRAPHQL_OPERATION_TYPES = new Set([
+    "query",
+    "mutation",
+    "subscription",
+]);
+// A named GraphQL operation header (GraphQL October 2021, OperationDefinition):
+// type, name, then variable definitions starting with `$`, a directive, or a
+// selection set starting with a field name.
+const GRAPHQL_OPERATION_HEADER = /^(query|mutation|subscription)[\s,]+([_A-Za-z][_0-9A-Za-z]*)[\s,]*(?:\([\s,]*\$|@[_A-Za-z]|\{[\s,]*[_A-Za-z])/u;
+const isGraphqlIgnoredCharacter = (character) => character === "," || character === "" || /\s/u.test(character);
+/** Recover a named operation from GraphQL document text. */
+export const graphqlOperationFromText = (text) => {
+    // Skip GraphQL ignored tokens: whitespace, commas, BOM and # comments.
+    const limit = text.length;
+    let index = 0;
+    while (index < limit) {
+        const character = text.charAt(index);
+        if (isGraphqlIgnoredCharacter(character))
+            index += 1;
+        else if (character === "#") {
+            while (index < limit && !/[\n\r]/u.test(text.charAt(index)))
+                index += 1;
+        }
+        else
+            break;
+    }
+    if (index >= limit)
+        return undefined;
+    const header = GRAPHQL_OPERATION_HEADER.exec(text.slice(index));
+    const type = header?.[1];
+    const name = header?.[2];
+    return type === undefined || name === undefined
+        ? undefined
+        : { value: name, mechanism: `graphql:${type}` };
+};
+/** Recover a named operation from a precompiled GraphQL document object. */
+export const graphqlOperationFromDocumentNode = (node) => {
+    if (objectStringProperty(node, "kind") !== "OperationDefinition")
+        return undefined;
+    const type = objectStringProperty(node, "operation");
+    if (type === undefined || !GRAPHQL_OPERATION_TYPES.has(type))
+        return undefined;
+    const name = objectProperty(node, "name");
+    if (!t.isObjectExpression(name) ||
+        objectStringProperty(name, "kind") !== "Name")
+        return undefined;
+    const value = objectStringProperty(name, "value");
+    return value === undefined
+        ? undefined
+        : { value, mechanism: `graphql:${type}` };
+};
+/** Bundlers use `(0, imported.factory)` to call an import without a receiver. */
+const rpcFactoryName = (callee) => {
+    let current = unwrapJavaScriptExpression(callee).node;
+    while (t.isSequenceExpression(current)) {
+        const last = current.expressions.at(-1);
+        if (last === undefined)
+            return "";
+        current = unwrapJavaScriptExpression(last).node;
+    }
+    return calleeName(current);
+};
+/** Whether an initializer has the syntax of a documented tRPC client factory. */
+export const isJavaScriptRpcClientFactory = (node) => {
+    const call = unwrapJavaScriptExpression(node).node;
+    return ((t.isCallExpression(call) || t.isOptionalCallExpression(call)) &&
+        TRPC_CLIENT_FACTORIES.has(rpcFactoryName(call.callee).split(".").pop() ?? ""));
+};
+/** Recover the literal `url` option passed to a documented tRPC HTTP link. */
+const trpcLinkUrl = (node) => {
+    const name = rpcFactoryName(node.callee);
+    const factory = name.slice(name.lastIndexOf(".") + 1);
+    if (!TRPC_URL_LINKS.has(factory))
+        return undefined;
+    const options = node.arguments[0];
+    if (!t.isObjectExpression(options))
+        return undefined;
+    const url = objectStringProperty(options, "url");
+    return url === undefined
+        ? undefined
+        : { value: url, mechanism: `trpc:link:${factory}` };
+};
+/**
+ * Create the per-source scan. Hook and option-factory methods are distinctive.
+ * `query`/`mutate` need a root bound to a tRPC client factory, or a tRPC source
+ * marker with a router path of at least two segments; `subscribe` needs the
+ * marker and a tRPC observer argument. `this` roots, browser globals and RTK
+ * Query `endpoints` chains are never procedures.
+ */
+export const createJavaScriptRpcScan = (source, clientRoots) => {
+    let marker;
+    const hasMarker = () => (marker ??= TRPC_SOURCE_MARKERS.some((value) => source.includes(value)));
+    // graphql-tag documents retain their source text in loc.source.body; that
+    // text repeats the OperationDefinition already recovered from the object.
+    const documentSourceBodies = new WeakSet();
+    const procedure = (node) => {
+        const path = memberPath(node.callee);
+        if (path === undefined || t.isThisExpression(path.root))
+            return undefined;
+        if (t.isIdentifier(path.root) && BROWSER_GLOBAL_NAMES.has(path.root.name))
+            return undefined;
+        const method = path.properties[path.properties.length - 1];
+        const segments = path.properties.slice(0, -1);
+        const first = segments[0];
+        if (method === undefined || first === undefined)
+            return undefined;
+        if (BROWSER_GLOBAL_NAMES.has(first) || segments.includes("endpoints"))
+            return undefined;
+        const bound = clientRoots.has(path.root);
+        const recognized = TRPC_HOOK_METHODS.has(method)
+            ? true
+            : TRPC_REQUEST_METHODS.has(method)
+                ? bound || (segments.length >= 2 && hasMarker())
+                : method === "subscribe" &&
+                    (bound || hasMarker()) &&
+                    objectKeys(node.arguments[1]).some((key) => TRPC_SUBSCRIPTION_CALLBACKS.has(key));
+        return recognized
+            ? { value: segments.join("."), mechanism: `trpc:procedure:${method}` }
+            : undefined;
+    };
+    return {
+        inspect: (node) => {
+            if (t.isCallExpression(node) || t.isOptionalCallExpression(node))
+                return trpcLinkUrl(node) ?? procedure(node);
+            if (t.isObjectExpression(node)) {
+                const body = objectProperty(node, "body");
+                if (t.isStringLiteral(body) &&
+                    objectProperty(node, "locationOffset") !== undefined) {
+                    documentSourceBodies.add(body);
+                    return undefined;
+                }
+                return graphqlOperationFromDocumentNode(node);
+            }
+            if (t.isStringLiteral(node))
+                return documentSourceBodies.has(node)
+                    ? undefined
+                    : graphqlOperationFromText(node.value);
+            if (t.isTemplateLiteral(node)) {
+                // A template recovered without a cooked value stays dynamic.
+                const cooked = node.quasis[0]?.value.cooked;
+                return cooked === undefined || cooked === null
+                    ? undefined
+                    : graphqlOperationFromText(cooked);
+            }
+            return undefined;
+        },
+    };
+};

package/dist/domain/javascript/javascriptRuntimeLoadState.js

@@ -0,0 +1,98 @@
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeScope, } from "./javascriptRuntimeStaticCandidates.js";
+/** Classify static code presence without claiming bundled module execution. */
+export const classifyStaticLoadStates = (layers, runtimeEntities, matches, options) => {
+    const states = [];
+    for (const layer of layers) {
+        const projection = classifyLayer(layer, runtimeEntities, matches, {
+            reconciliationComplete: options.reconciliationComplete,
+        });
+        states.push(...projection.states);
+    }
+    return { states, omittedStates: 0 };
+};
+const classifyLayer = (layer, runtimeEntities, matches, options) => {
+    const nodes = layer.graph.nodes.filter(isLoadStateNode);
+    const direct = new Map();
+    for (const match of matches)
+        if (match.status === "matched" &&
+            match.static_layer_id === layer.layerId &&
+            match.static_node_id !== null)
+            append(direct, match.static_node_id, match.runtime_node_id);
+    const resident = residentNodes(layer, new Set(direct.keys()));
+    const runtimeScope = createStaticRuntimeScope(layer, runtimeEntities);
+    const scopedEntities = runtimeEntities.filter((entity) => mappedRuntimePaths(layer, entity).length > 0);
+    const layerComplete = options.reconciliationComplete &&
+        layer.graph.coverage.status === "complete" &&
+        scopedEntities.length > 0 &&
+        scopedEntities.every(({ capture }) => capture.scriptsCompleteWithinScope);
+    const states = nodes.map((node) => {
+        const runtimeNodeIds = uniqueSorted(direct.get(node.node_id) ?? []);
+        if (runtimeNodeIds.length > 0)
+            return state(layer, node, {
+                status: "loaded",
+                runtimeNodeIds,
+                reason: "runtime-script-correspondence",
+            });
+        if (resident.has(node.node_id))
+            return state(layer, node, {
+                status: "resident-in-loaded-asset",
+                runtimeNodeIds: [],
+                reason: "containing-asset-was-loaded",
+            });
+        const nodeWithinScope = staticNodeWithinRuntimeScope(node, runtimeScope);
+        if (layerComplete && nodeWithinScope)
+            return state(layer, node, {
+                status: "not-observed-in-capture",
+                runtimeNodeIds: [],
+                reason: "not-observed-in-bounded-capture",
+            });
+        return state(layer, node, {
+            status: "unknown",
+            runtimeNodeIds: [],
+            reason: !nodeWithinScope
+                ? "layer-outside-runtime-scope"
+                : "static-or-runtime-coverage-incomplete",
+        });
+    });
+    return { states };
+};
+const residentNodes = (layer, directlyLoaded) => {
+    const nodeKinds = new Map(layer.graph.nodes.map(({ node_id: id, kind }) => [id, kind]));
+    const children = new Map();
+    for (const edge of layer.graph.edges)
+        if (edge.relation === "contains")
+            append(children, edge.source_node_id, edge.target_node_id);
+    const pending = [...directlyLoaded].filter((nodeId) => nodeKinds.get(nodeId) === "javascript-asset");
+    const resident = new Set();
+    for (let index = 0; index < pending.length; index += 1) {
+        const current = pending[index];
+        if (current === undefined)
+            break;
+        for (const child of children.get(current) ?? []) {
+            if (resident.has(child))
+                continue;
+            resident.add(child);
+            pending.push(child);
+        }
+    }
+    return resident;
+};
+const append = (values, key, value) => {
+    const current = values.get(key);
+    if (current === undefined)
+        values.set(key, [value]);
+    else
+        current.push(value);
+};
+const isLoadStateNode = (node) => node.kind === "javascript-asset" ||
+    node.kind === "javascript-chunk" ||
+    node.kind === "javascript-module";
+const state = (layer, node, input) => ({
+    static_layer_id: layer.layerId,
+    static_node_id: node.node_id,
+    kind: node.kind,
+    status: input.status,
+    runtime_node_ids: [...input.runtimeNodeIds],
+    reason: input.reason,
+});