rea-agents 2.2.0 → 2.3.0

package/dist/domain/javascriptSemanticCalls.js

@@ -0,0 +1,269 @@
+import * as t from "@babel/types";
+import { reachSemanticLimit, semanticCallableIdForNode, semanticReferenceRole, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { parameterBindings, resolveLocalCallables, } from "./javascriptSemanticCallResolution.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
+/** Recover bounded direct-call and lexical-capture candidates from inert syntax. */
+export const collectJavaScriptSemanticCalls = (program, state, callables) => {
+    const output = {
+        callSites: [],
+        argumentFlows: [],
+        callReturnFlows: [],
+        callResultFlows: [],
+        closureCaptures: [],
+        frontiers: [],
+        retainedArguments: 0,
+    };
+    const callableById = new Map(callables.map((callable) => [callable.callableId, callable]));
+    const context = {
+        state,
+        callableById,
+        output,
+        bindingResolutionCache: new Map(),
+        parameterBindingCache: new Map(),
+    };
+    const callableStack = [];
+    traverseJavaScriptAst(program, {
+        enter: (node, parent) => {
+            const callableId = semanticCallableIdForNode(node);
+            const callable = callableId === null ? undefined : callableById.get(callableId);
+            if (callable !== undefined)
+                callableStack.push(callable);
+            const owner = enclosingFunction(callableStack);
+            collectCapture(node, parent, owner, context);
+            collectDynamicProperty(node, owner, state, output);
+            if (t.isCallExpression(node) ||
+                t.isOptionalCallExpression(node) ||
+                t.isNewExpression(node))
+                collectCallSite(node, parent, owner, context);
+        },
+        exit: (node) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null &&
+                callableStack.at(-1)?.callableId === callableId)
+                callableStack.pop();
+        },
+    });
+    return {
+        callSites: output.callSites,
+        argumentFlows: output.argumentFlows,
+        callReturnFlows: output.callReturnFlows,
+        callResultFlows: output.callResultFlows,
+        closureCaptures: output.closureCaptures,
+        frontiers: output.frontiers,
+    };
+};
+const collectCallSite = (node, parent, owner, context) => {
+    const { state, callableById, output } = context;
+    if (output.callSites.length >= state.limits.maxCallSites) {
+        reachSemanticLimit(state, "maxCallSites");
+        return;
+    }
+    const resolution = resolveLocalCallables({
+        node: node.callee,
+        state,
+        callableById,
+        seenBindings: new Set(),
+        depth: 0,
+        bindingCache: context.bindingResolutionCache,
+    });
+    const callSiteId = semanticCallSiteId(node);
+    const argumentsValue = retainedArguments(node.arguments, state, output);
+    const site = {
+        callSiteId,
+        kind: t.isNewExpression(node) ? "construct" : "call",
+        callerCallableId: owner?.callableId ?? null,
+        location: range(node),
+        calleeLocation: range(node.callee),
+        resolution: resolution.callableIds.length === 1 && resolution.complete
+            ? "exact"
+            : resolution.callableIds.length > 0
+                ? "ambiguous"
+                : "unresolved",
+        calleeCallableIds: resolution.callableIds,
+        arguments: argumentsValue,
+    };
+    output.callSites.push(site);
+    collectCallResultFlow(site, node, parent, context);
+    if (site.resolution !== "exact")
+        addFrontier({
+            kind: "dynamic-call",
+            callableId: owner?.callableId ?? null,
+            location: range(node.callee),
+            reason: resolution.reason,
+        }, state, output);
+    collectArgumentFlows(site, node, context);
+    if (site.kind === "call")
+        collectReturnFlows(site, callableById, state, output);
+};
+const collectCallResultFlow = (site, node, parent, context) => {
+    const identifier = t.isVariableDeclarator(parent) &&
+        parent.init === node &&
+        t.isIdentifier(parent.id)
+        ? parent.id
+        : t.isAssignmentExpression(parent) &&
+            parent.right === node &&
+            t.isIdentifier(parent.left)
+            ? parent.left
+            : null;
+    if (identifier === null)
+        return;
+    const binding = resolveSemanticBindingState(context.state, identifier, identifier.name);
+    const identifierRange = range(identifier);
+    const definition = binding?.definitions.find(({ location }) => location.start.line === identifierRange.start.line &&
+        location.start.column === identifierRange.start.column &&
+        location.end.line === identifierRange.end.line &&
+        location.end.column === identifierRange.end.column);
+    if (binding === undefined || definition === undefined)
+        return;
+    context.output.callResultFlows.push({
+        callSiteId: site.callSiteId,
+        bindingId: binding.bindingId,
+        definitionLocation: definition.location,
+    });
+};
+const retainedArguments = (nodes, state, output) => {
+    const retained = [];
+    for (const [index, node] of nodes.entries()) {
+        if (output.retainedArguments >= state.limits.maxCallArguments) {
+            reachSemanticLimit(state, "maxCallArguments");
+            break;
+        }
+        output.retainedArguments += 1;
+        retained.push({
+            index,
+            location: range(node),
+            spread: t.isSpreadElement(node),
+        });
+    }
+    return retained;
+};
+const collectArgumentFlows = (site, node, context) => {
+    const { state, callableById, output } = context;
+    const retainedIndexes = new Set(site.arguments.map(({ index }) => index));
+    let positionIsExact = true;
+    for (const [index, argument] of node.arguments.entries()) {
+        if (t.isSpreadElement(argument)) {
+            positionIsExact = false;
+            continue;
+        }
+        if (!positionIsExact ||
+            !retainedIndexes.has(index) ||
+            !t.isExpression(argument))
+            continue;
+        for (const callableId of site.calleeCallableIds) {
+            const callable = callableById.get(callableId);
+            if (callable === undefined)
+                continue;
+            for (const parameter of cachedParameterBindings(callable, index, context)) {
+                if (output.argumentFlows.length >= state.limits.maxArgumentFlows) {
+                    reachSemanticLimit(state, "maxArgumentFlows");
+                    return;
+                }
+                const definition = parameter.definitions.find(({ kind }) => kind === "parameter");
+                if (definition === undefined)
+                    continue;
+                output.argumentFlows.push({
+                    callSiteId: site.callSiteId,
+                    argumentIndex: index,
+                    argumentLocation: range(argument),
+                    callableId,
+                    parameterBindingId: parameter.bindingId,
+                    parameterLocation: definition.location,
+                });
+            }
+        }
+    }
+};
+const cachedParameterBindings = (callable, index, context) => {
+    const key = `${callable.callableId}:${String(index)}`;
+    const cached = context.parameterBindingCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const bindings = parameterBindings(callable, index, context.state);
+    context.parameterBindingCache.set(key, bindings);
+    return bindings;
+};
+const collectReturnFlows = (site, callableById, state, output) => {
+    for (const callableId of site.calleeCallableIds) {
+        const callable = callableById.get(callableId);
+        if (callable === undefined)
+            continue;
+        for (const returnSite of callable.returnSites) {
+            if (output.callReturnFlows.length >= state.limits.maxCallReturnFlows) {
+                reachSemanticLimit(state, "maxCallReturnFlows");
+                return;
+            }
+            output.callReturnFlows.push({
+                callSiteId: site.callSiteId,
+                callableId,
+                returnSiteId: returnSite.returnSiteId,
+                returnLocation: returnSite.location,
+            });
+        }
+    }
+};
+const collectCapture = (node, parent, owner, context) => {
+    const { state, output } = context;
+    if (!t.isIdentifier(node) ||
+        parent === null ||
+        owner === undefined ||
+        owner.bodyScopeId === null)
+        return;
+    if (semanticReferenceRole(node, parent) === null)
+        return;
+    const binding = resolveSemanticBindingState(state, node, node.name);
+    if (binding === undefined ||
+        bindingIsWithinCallable(binding, owner.bodyScopeId, state))
+        return;
+    if (output.closureCaptures.length >= state.limits.maxClosureCaptures) {
+        reachSemanticLimit(state, "maxClosureCaptures");
+        return;
+    }
+    output.closureCaptures.push({
+        callableId: owner.callableId,
+        bindingId: binding.bindingId,
+        referenceLocation: range(node),
+    });
+};
+const collectDynamicProperty = (node, owner, state, output) => {
+    if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
+        semanticStaticPropertyName(node.property, node.computed) === "")
+        addFrontier({
+            kind: "dynamic-property",
+            callableId: owner?.callableId ?? null,
+            location: range(node.property),
+            reason: "Computed member property is not a static string or number.",
+        }, state, output);
+    else if ((t.isObjectProperty(node) || t.isObjectMethod(node)) &&
+        node.computed &&
+        semanticStaticPropertyName(node.key, true) === "")
+        addFrontier({
+            kind: "dynamic-property",
+            callableId: owner?.callableId ?? null,
+            location: range(node.key),
+            reason: "Computed object property is not a static string or number.",
+        }, state, output);
+};
+const addFrontier = (frontier, state, output) => {
+    if (output.frontiers.length >= state.limits.maxFrontiers) {
+        reachSemanticLimit(state, "maxFrontiers");
+        return;
+    }
+    output.frontiers.push(frontier);
+};
+const bindingIsWithinCallable = (binding, bodyScopeId, state) => {
+    let scope = state.scopesById.get(binding.scopeId);
+    while (scope !== undefined) {
+        if (scope.scopeId === bodyScopeId)
+            return true;
+        scope =
+            scope.parentScopeId === null
+                ? undefined
+                : state.scopesById.get(scope.parentScopeId);
+    }
+    return false;
+};
+const enclosingFunction = (stack) => stack.findLast(({ kind }) => kind !== "class");
+const semanticCallSiteId = (node) => `call:${t.isNewExpression(node) ? "construct" : "call"}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;

package/dist/domain/javascriptSemanticGraph.js

@@ -0,0 +1,356 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, javaScriptSemanticFingerprintInputSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticGraphRecordSchema, javaScriptSemanticNodeInputSchema, javaScriptSemanticNodeSchema, javaScriptSemanticRelationInputSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownInputSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
+const canonicalJson = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("JavaScript semantic graph could not canonicalize data");
+    return encoded;
+};
+const digestCanonical = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
+const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);
+const normalizeEvidence = (evidence) => ({
+    ...evidence,
+    coverage: {
+        ...evidence.coverage,
+        limits: [...evidence.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right))),
+    },
+    limitations: uniqueSorted(evidence.limitations),
+    evidence_ids: uniqueSorted(evidence.evidence_ids),
+});
+const nodeId = (node) => `jsrg_node_${digestCanonical({ kind: node.kind, identity: node.identity })}`;
+/** Normalize one semantic entity and derive its artifact-version identifier. */
+export const createJavaScriptSemanticGraphNode = (input) => {
+    const parsed = javaScriptSemanticNodeInputSchema.parse(input);
+    const semantic = {
+        ...parsed,
+        application_node_ids: uniqueSorted(parsed.application_node_ids),
+        evidence: normalizeEvidence(parsed.evidence),
+        identifier_strategy: {
+            strategy: "semantic-content-sha256",
+            stability: "artifact-version",
+        },
+    };
+    return javaScriptSemanticNodeSchema.parse({
+        ...semantic,
+        node_id: nodeId(semantic),
+    });
+};
+/** Normalize one semantic relationship and derive its exact identifier. */
+export const createJavaScriptSemanticGraphRelation = (input) => {
+    const parsed = javaScriptSemanticRelationInputSchema.parse(input);
+    const semantic = {
+        ...parsed,
+        evidence: normalizeEvidence(parsed.evidence),
+        identifier_strategy: {
+            strategy: "semantic-content-sha256",
+            stability: "relationship-exact",
+        },
+    };
+    return javaScriptSemanticRelationSchema.parse({
+        ...semantic,
+        relation_id: `jsrg_relation_${digestCanonical(semantic)}`,
+    });
+};
+/** Normalize one unresolved semantic frontier and derive its identifier. */
+export const createJavaScriptSemanticGraphUnknown = (input) => {
+    const parsed = javaScriptSemanticUnknownInputSchema.parse(input);
+    const semantic = {
+        ...parsed,
+        relation_kinds: uniqueSorted(parsed.relation_kinds),
+        candidate_node_ids: uniqueSorted(parsed.candidate_node_ids),
+        evidence: normalizeEvidence(parsed.evidence),
+    };
+    return javaScriptSemanticUnknownSchema.parse({
+        ...semantic,
+        unknown_id: `jsrg_unknown_${digestCanonical(semantic)}`,
+    });
+};
+/** Normalize one function fingerprint and derive its component commitment. */
+export const createJavaScriptSemanticFingerprint = (input) => {
+    const parsed = javaScriptSemanticFingerprintInputSchema.parse(input);
+    const semantic = {
+        ...parsed,
+        components: {
+            ...parsed.components,
+            effects: uniqueSorted(parsed.components.effects),
+        },
+        limitations: uniqueSorted(parsed.limitations),
+        evidence: normalizeEvidence(parsed.evidence),
+    };
+    const fingerprintSha256 = digestCanonical(semantic.components);
+    return javaScriptSemanticFingerprintSchema.parse({
+        ...semantic,
+        fingerprint_sha256: fingerprintSha256,
+        fingerprint_id: `jsrg_fingerprint_${digestCanonical({
+            function_node_id: semantic.function_node_id,
+            algorithm: semantic.algorithm,
+            fingerprint_sha256: fingerprintSha256,
+        })}`,
+    });
+};
+const sortedUniqueIssue = (values, path, label, context) => {
+    for (let index = 1; index < values.length; index += 1) {
+        if (compareCodePoints(values[index - 1] ?? "", values[index] ?? "") < 0)
+            continue;
+        context.addIssue({
+            code: "custom",
+            path: [...path, index],
+            message: `${label} must be sorted and unique`,
+        });
+        return;
+    }
+};
+const checkCoverage = (graph, context) => {
+    const families = graph.coverage.families.map(({ family }) => family);
+    if (canonicalJson(families) !==
+        canonicalJson(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES))
+        context.addIssue({
+            code: "custom",
+            path: ["coverage", "families"],
+            message: "Coverage must name every semantic relation family once in canonical order",
+        });
+    if (graph.coverage.status === "complete" &&
+        (graph.coverage.truncated ||
+            graph.coverage.omitted_nodes !== 0 ||
+            graph.coverage.omitted_relations !== 0 ||
+            graph.coverage.families.some(({ status }) => status !== "complete")))
+        context.addIssue({
+            code: "custom",
+            path: ["coverage"],
+            message: "Complete graph coverage cannot omit or truncate semantic facts",
+        });
+    if (graph.coverage.truncated && graph.coverage.limits.length === 0)
+        context.addIssue({
+            code: "custom",
+            path: ["coverage", "limits"],
+            message: "Truncated graph coverage must identify an effective limit",
+        });
+    const relationsByFamily = new Map(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => [family, 0]));
+    for (const relation of graph.relations) {
+        const family = JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation.relation];
+        relationsByFamily.set(family, (relationsByFamily.get(family) ?? 0) + 1);
+    }
+    const unknownsById = new Map(graph.unknowns.map((unknown) => [unknown.unknown_id, unknown]));
+    for (const [index, family] of graph.coverage.families.entries()) {
+        if (family.retained_relations !== relationsByFamily.get(family.family))
+            context.addIssue({
+                code: "custom",
+                path: ["coverage", "families", index, "retained_relations"],
+                message: "Family retained relation count does not match graph content",
+            });
+        if (family.unknown_ids.some((identifier) => unknownsById.get(identifier)?.family !== family.family))
+            context.addIssue({
+                code: "custom",
+                path: ["coverage", "families", index, "unknown_ids"],
+                message: "Family coverage references an unknown from another family",
+            });
+        if (family.status === "complete" &&
+            (family.omitted_relations !== 0 || family.unknown_ids.length > 0))
+            context.addIssue({
+                code: "custom",
+                path: ["coverage", "families", index],
+                message: "Complete family coverage cannot omit or retain unknown facts",
+            });
+    }
+};
+const checkCanonicalOrder = (graph, context) => {
+    sortedUniqueIssue(graph.root_node_ids, ["root_node_ids"], "Root nodes", context);
+    sortedUniqueIssue(graph.nodes.map(({ node_id }) => node_id), ["nodes"], "Nodes", context);
+    sortedUniqueIssue(graph.relations.map(({ relation_id }) => relation_id), ["relations"], "Relations", context);
+    sortedUniqueIssue(graph.fingerprints.map(({ fingerprint_id }) => fingerprint_id), ["fingerprints"], "Fingerprints", context);
+    sortedUniqueIssue(graph.unknowns.map(({ unknown_id }) => unknown_id), ["unknowns"], "Unknown frontiers", context);
+    sortedUniqueIssue(graph.limitations, ["limitations"], "Limitations", context);
+};
+const checkNodes = (graph, nodes, context) => {
+    for (const [index, node] of graph.nodes.entries()) {
+        if (node.node_id !== nodeId(node))
+            context.addIssue({
+                code: "custom",
+                path: ["nodes", index, "node_id"],
+                message: "Node identifier is stale",
+            });
+        if (node.function_node_id !== null &&
+            nodes.get(node.function_node_id)?.kind !== "function")
+            context.addIssue({
+                code: "custom",
+                path: ["nodes", index, "function_node_id"],
+                message: "Function owner must name a function node",
+            });
+    }
+};
+const checkRoots = (graph, nodes, context) => {
+    for (const root of graph.root_node_ids)
+        if (!nodes.has(root))
+            context.addIssue({
+                code: "custom",
+                path: ["root_node_ids"],
+                message: "Root identifier must name a semantic node",
+            });
+};
+const checkRelations = (graph, nodes, context) => {
+    for (const [index, relation] of graph.relations.entries()) {
+        const { relation_id: identifier, ...semantic } = relation;
+        if (identifier !== "jsrg_relation_" + digestCanonical(semantic))
+            context.addIssue({
+                code: "custom",
+                path: ["relations", index, "relation_id"],
+                message: "Relation identifier is stale",
+            });
+        if (!nodes.has(relation.source_node_id) ||
+            !nodes.has(relation.target_node_id))
+            context.addIssue({
+                code: "custom",
+                path: ["relations", index],
+                message: "Relation endpoints must name semantic nodes",
+            });
+        if (relation.source_node_id === relation.target_node_id)
+            context.addIssue({
+                code: "custom",
+                path: ["relations", index],
+                message: "Semantic relations cannot be self-referential",
+            });
+        if (relation.resolution === "candidate" &&
+            relation.evidence.state === "observed")
+            context.addIssue({
+                code: "custom",
+                path: ["relations", index, "evidence", "state"],
+                message: "Candidate relations cannot claim observed resolution",
+            });
+    }
+};
+const checkUnknowns = (graph, nodes, context) => {
+    for (const [index, unknown] of graph.unknowns.entries()) {
+        const { unknown_id: identifier, ...semantic } = unknown;
+        if (identifier !== "jsrg_unknown_" + digestCanonical(semantic))
+            context.addIssue({
+                code: "custom",
+                path: ["unknowns", index, "unknown_id"],
+                message: "Unknown frontier identifier is stale",
+            });
+        if (unknown.node_id !== null && !nodes.has(unknown.node_id))
+            context.addIssue({
+                code: "custom",
+                path: ["unknowns", index, "node_id"],
+                message: "Unknown frontier node is absent",
+            });
+        if (unknown.candidate_node_ids.some((nodeId) => !nodes.has(nodeId)))
+            context.addIssue({
+                code: "custom",
+                path: ["unknowns", index, "candidate_node_ids"],
+                message: "Unknown frontier candidate node is absent",
+            });
+        if (unknown.relation_kinds.some((kind) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[kind] !== unknown.family))
+            context.addIssue({
+                code: "custom",
+                path: ["unknowns", index, "relation_kinds"],
+                message: "Unknown relation kinds must belong to their declared family",
+            });
+        if (!["unknown", "unavailable"].includes(unknown.evidence.state))
+            context.addIssue({
+                code: "custom",
+                path: ["unknowns", index, "evidence", "state"],
+                message: "Unknown frontiers require unknown or unavailable evidence",
+            });
+    }
+};
+const checkUnknownReferences = (graph, context) => {
+    const unknownIds = new Set(graph.unknowns.map(({ unknown_id }) => unknown_id));
+    for (const [index, family] of graph.coverage.families.entries())
+        if (family.unknown_ids.some((identifier) => !unknownIds.has(identifier)))
+            context.addIssue({
+                code: "custom",
+                path: ["coverage", "families", index, "unknown_ids"],
+                message: "Family coverage references an absent unknown frontier",
+            });
+};
+const checkFingerprints = (graph, nodes, context) => {
+    for (const [index, fingerprint] of graph.fingerprints.entries()) {
+        if (nodes.get(fingerprint.function_node_id)?.kind !== "function")
+            context.addIssue({
+                code: "custom",
+                path: ["fingerprints", index, "function_node_id"],
+                message: "Fingerprint must name a function node",
+            });
+        if (fingerprint.fingerprint_sha256 !== digestCanonical(fingerprint.components))
+            context.addIssue({
+                code: "custom",
+                path: ["fingerprints", index, "fingerprint_sha256"],
+                message: "Fingerprint component commitment is stale",
+            });
+        const expectedIdentifier = "jsrg_fingerprint_" +
+            digestCanonical({
+                function_node_id: fingerprint.function_node_id,
+                algorithm: fingerprint.algorithm,
+                fingerprint_sha256: fingerprint.fingerprint_sha256,
+            });
+        if (fingerprint.fingerprint_id !== expectedIdentifier)
+            context.addIssue({
+                code: "custom",
+                path: ["fingerprints", index, "fingerprint_id"],
+                message: "Fingerprint identifier is stale",
+            });
+        if (fingerprint.status !== "complete" &&
+            fingerprint.limitations.length === 0)
+            context.addIssue({
+                code: "custom",
+                path: ["fingerprints", index, "limitations"],
+                message: "Incomplete fingerprints require a limitation",
+            });
+    }
+};
+const checkGraph = (graph, context) => {
+    checkCanonicalOrder(graph, context);
+    const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
+    checkNodes(graph, nodes, context);
+    checkRoots(graph, nodes, context);
+    checkRelations(graph, nodes, context);
+    checkUnknowns(graph, nodes, context);
+    checkUnknownReferences(graph, context);
+    checkFingerprints(graph, nodes, context);
+    checkCoverage(graph, context);
+    if (graph.coverage.status !== "complete" && graph.limitations.length === 0)
+        context.addIssue({
+            code: "custom",
+            path: ["limitations"],
+            message: "Non-complete graph coverage requires a limitation",
+        });
+    const { graph_id: identifier, ...semantic } = graph;
+    if (identifier !== "jsrg_" + digestCanonical(semantic))
+        context.addIssue({
+            code: "custom",
+            path: ["graph_id"],
+            message: "Graph identifier is stale",
+        });
+};
+/** Strict semantic graph schema with verified canonical commitments. */
+export const javaScriptSemanticGraphSchema = javaScriptSemanticGraphRecordSchema.superRefine(checkGraph);
+/** Normalize a complete companion graph and derive its graph ID. */
+export const createJavaScriptSemanticGraph = (input) => {
+    const parsed = javaScriptSemanticGraphInputSchema.parse(input);
+    const semantic = {
+        ...parsed,
+        root_node_ids: uniqueSorted(parsed.root_node_ids),
+        nodes: [...parsed.nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id)),
+        relations: [...parsed.relations].sort((left, right) => compareCodePoints(left.relation_id, right.relation_id)),
+        fingerprints: [...parsed.fingerprints].sort((left, right) => compareCodePoints(left.fingerprint_id, right.fingerprint_id)),
+        unknowns: [...parsed.unknowns].sort((left, right) => compareCodePoints(left.unknown_id, right.unknown_id)),
+        coverage: {
+            ...parsed.coverage,
+            limits: [...parsed.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right))),
+            families: [...parsed.coverage.families]
+                .map((family) => ({
+                ...family,
+                unknown_ids: uniqueSorted(family.unknown_ids),
+            }))
+                .sort((left, right) => compareCodePoints(left.family, right.family)),
+        },
+        limitations: uniqueSorted(parsed.limitations),
+    };
+    return javaScriptSemanticGraphSchema.parse({
+        ...semantic,
+        graph_id: `jsrg_${digestCanonical(semantic)}`,
+    });
+};