rea-agents 2.4.0 → 2.5.0

package/dist/domain/sourceToBundleComparison.js

@@ -0,0 +1,335 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, sourceToBundleComparisonResultSchema, } from "./sourceToBundleComparisonSchemas.js";
+import { buildSourceToBundleCandidateIndex, candidateIdsForSource, historicalSourceFiles, scoreSourceToBundleCandidate, sourceBearingNodes, } from "./sourceToBundleSignals.js";
+/** Compare historical source files to static source-bearing application nodes. */
+export const compareSourceToBundle = (input) => {
+    const projection = projectComparison(input);
+    const mappings = compareMappings(input, projection);
+    const factors = {
+        ...projection.factors,
+        omittedCandidateEvaluations: mappings.omittedCandidateEvaluations,
+        omittedCandidateReferences: mappings.omittedCandidateReferences,
+    };
+    const mappedCurrentIds = new Set(mappings.items.flatMap(({ current_node_ids: nodeIds }) => nodeIds));
+    const unmappedCurrentNodeIds = projection.currentNodes
+        .map(({ node_id: nodeId }) => nodeId)
+        .filter((nodeId) => !mappedCurrentIds.has(nodeId));
+    const semanticResult = {
+        schema_version: 1,
+        reference: {
+            root_sha256: input.reference.root_sha256,
+            inventory_state: input.reference.inventory_state,
+        },
+        application: {
+            evidence_id: input.application.evidenceId,
+            graph_id: input.application.graph.graph_id,
+            root_artifact_sha256: input.application.rootArtifactSha256,
+        },
+        scoring: scoringModel(),
+        summary: comparisonSummary(mappings.items),
+        items: mappings.items,
+        unmapped_current_node_ids: unmappedCurrentNodeIds,
+        coverage: comparisonCoverage(projection, mappings, factors),
+        evidence_links: [input.application.evidenceId],
+        limitations: comparisonLimitations(factors),
+    };
+    return sourceToBundleComparisonResultSchema.parse({
+        ...semanticResult,
+        comparison_id: `stbc_${digestCanonical(semanticResult)}`,
+    });
+};
+const projectComparison = (input) => {
+    const allSources = historicalSourceFiles(input.reference);
+    const allCurrentNodes = sourceBearingNodes(input.application.graph.nodes);
+    const sources = allSources.slice(0, input.limits.max_source_files);
+    const currentNodes = allCurrentNodes.slice(0, input.limits.max_application_nodes);
+    const omittedSourceFiles = allSources.length - sources.length;
+    const omittedApplicationNodes = allCurrentNodes.length - currentNodes.length;
+    const index = buildSourceToBundleCandidateIndex(currentNodes);
+    return {
+        sources,
+        currentNodes,
+        index,
+        absenceComplete: input.reference.inventory_state === "complete" &&
+            input.application.graph.coverage.status === "complete" &&
+            !input.application.graph.coverage.truncated &&
+            omittedSourceFiles === 0 &&
+            omittedApplicationNodes === 0 &&
+            !index.pathIndexTruncated,
+        factors: {
+            input,
+            omittedSourceFiles,
+            omittedApplicationNodes,
+            omittedCandidateEvaluations: 0,
+            omittedCandidateReferences: 0,
+            pathIndexTruncated: index.pathIndexTruncated,
+        },
+    };
+};
+const compareMappings = (input, projection) => {
+    let evaluationsRemaining = input.limits.max_candidate_evaluations;
+    let candidateEvaluations = 0;
+    let omittedCandidateEvaluations = 0;
+    let omittedCandidateReferences = 0;
+    const provisionalItems = [];
+    for (const source of projection.sources) {
+        const candidateIds = candidateIdsForSource(source, projection.index);
+        const retainedIds = candidateIds.slice(0, evaluationsRemaining);
+        const omittedEvaluations = candidateIds.length - retainedIds.length;
+        evaluationsRemaining -= retainedIds.length;
+        candidateEvaluations += retainedIds.length;
+        omittedCandidateEvaluations += omittedEvaluations;
+        const scored = retainedIds
+            .map((nodeId) => scoreSourceToBundleCandidate(source, nodeId, projection.index))
+            .filter((candidate) => candidate !== null)
+            .sort(compareCandidates);
+        const retainedCandidates = scored.slice(0, input.limits.max_candidate_nodes);
+        const omittedCandidates = omittedEvaluations + scored.length - retainedCandidates.length;
+        omittedCandidateReferences += omittedCandidates;
+        const classification = classifyMapping(retainedCandidates, omittedCandidates === 0, projection.absenceComplete);
+        const semantic = {
+            source_path: source.path,
+            source_sha256: source.sha256,
+            source_language: source.language,
+            status: classification.status,
+            confidence: classification.confidence,
+            current_node_ids: classification.currentNodeIds,
+            candidates: retainedCandidates,
+            omitted_candidates: omittedCandidates,
+            limitations: uniqueSorted([
+                ...source.limitations,
+                ...classification.limitations,
+                ...(omittedCandidates > 0
+                    ? [
+                        `${String(omittedCandidates)} candidate references were omitted by comparison limits.`,
+                    ]
+                    : []),
+            ]),
+        };
+        provisionalItems.push({
+            mapping_id: mappingId(input, semantic),
+            ...semantic,
+        });
+    }
+    return {
+        items: markMergedMappings(input, provisionalItems),
+        candidateEvaluations,
+        omittedCandidateEvaluations,
+        omittedCandidateReferences,
+    };
+};
+const comparisonCoverage = (projection, mappings, factors) => ({
+    status: coverageStatus(factors),
+    reference_inventory_state: factors.input.reference.inventory_state,
+    application_graph_status: factors.input.application.graph.coverage.status,
+    retained_source_files: projection.sources.length,
+    omitted_source_files: factors.omittedSourceFiles,
+    retained_application_nodes: projection.currentNodes.length,
+    omitted_application_nodes: factors.omittedApplicationNodes,
+    candidate_evaluations: mappings.candidateEvaluations,
+    omitted_candidate_evaluations: mappings.omittedCandidateEvaluations,
+    omitted_candidate_references: mappings.omittedCandidateReferences,
+    omitted_unmapped_current_nodes: 0,
+});
+const scoringModel = () => ({
+    algorithm: "rea-source-to-bundle-signals/v1",
+    minimum_candidate_score: 20,
+    weights: Object.entries(SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS).map(([signal, weight]) => ({
+        signal: signal,
+        weight,
+    })),
+});
+const classifyMapping = (candidates, evaluationComplete, absenceComplete) => {
+    if (!evaluationComplete)
+        return {
+            status: "unknown",
+            confidence: "unknown",
+            currentNodeIds: [],
+            limitations: [
+                "Candidate evaluation stopped at the declared limit; a stronger match may be omitted.",
+            ],
+        };
+    const exact = candidates.filter((candidate) => hasSignal(candidate, "exact-source-digest"));
+    if (exact.length === 1)
+        return {
+            status: "unchanged",
+            confidence: "exact",
+            currentNodeIds: [exact[0]?.current_node_id ?? ""].filter(Boolean),
+            limitations: [
+                "Exact byte identity does not establish equivalent load context or runtime behavior.",
+            ],
+        };
+    if (exact.length > 1)
+        return {
+            status: "duplicated",
+            confidence: "exact",
+            currentNodeIds: exact.map(({ current_node_id: nodeId }) => nodeId),
+            limitations: [
+                "The same historical source digest occurs in multiple current graph nodes.",
+            ],
+        };
+    const pathCandidates = candidates.filter((candidate) => candidate.signals.some(({ kind }) => [
+        "source-map-original-path",
+        "current-path-exact",
+        "current-path-suffix",
+    ].includes(kind)));
+    const topScore = pathCandidates[0]?.score;
+    const topPathCandidates = topScore === undefined
+        ? []
+        : pathCandidates.filter(({ score }) => score === topScore);
+    if (topPathCandidates.length === 1) {
+        const candidate = topPathCandidates[0];
+        return {
+            status: "unknown",
+            confidence: "unknown",
+            currentNodeIds: candidate === undefined ? [] : [candidate.current_node_id],
+            limitations: [
+                "Location evidence links the source to the current node, but comparable source digests are unavailable.",
+            ],
+        };
+    }
+    if (topPathCandidates.length > 1)
+        return {
+            status: "split",
+            confidence: "medium",
+            currentNodeIds: topPathCandidates.map(({ current_node_id: nodeId }) => nodeId),
+            limitations: [
+                "Multiple equally scored current nodes retain the historical source path; this is a static split inference, not runtime proof.",
+            ],
+        };
+    if (candidates.length > 0)
+        return {
+            status: "unknown",
+            confidence: "unknown",
+            currentNodeIds: [],
+            limitations: [
+                "Only weak basename or extension signals were available; no mapping was forced.",
+            ],
+        };
+    return absenceComplete
+        ? {
+            status: "removed",
+            confidence: "high",
+            currentNodeIds: [],
+            limitations: [
+                "No retained current node matched exact digest or path signals within complete static inventories.",
+            ],
+        }
+        : {
+            status: "unknown",
+            confidence: "unknown",
+            currentNodeIds: [],
+            limitations: [
+                "No candidate was observed, but incomplete input or graph coverage prevents a removal claim.",
+            ],
+        };
+};
+const markMergedMappings = (input, items) => {
+    const sourcesByNode = new Map();
+    for (const item of items) {
+        if (item.status !== "unchanged" || item.current_node_ids.length !== 1)
+            continue;
+        const nodeId = item.current_node_ids[0];
+        if (nodeId === undefined)
+            continue;
+        sourcesByNode.set(nodeId, [...(sourcesByNode.get(nodeId) ?? []), item]);
+    }
+    const mergedSources = new Set([...sourcesByNode.values()]
+        .filter((group) => group.length > 1)
+        .flatMap((group) => group.map(({ source_path: path }) => path)));
+    return items.map((item) => {
+        if (!mergedSources.has(item.source_path))
+            return item;
+        const { mapping_id: previousMappingId, ...base } = item;
+        void previousMappingId;
+        const semantic = {
+            ...base,
+            status: "merged",
+            confidence: "exact",
+            limitations: uniqueSorted([
+                ...item.limitations,
+                "Multiple historical source paths have exact digest identity with the same current graph node.",
+            ]),
+        };
+        return { ...semantic, mapping_id: mappingId(input, semantic) };
+    });
+};
+const mappingId = (input, item) => `stbc_item_${digestCanonical({
+    reference_root_sha256: input.reference.root_sha256,
+    application_graph_id: input.application.graph.graph_id,
+    ...item,
+})}`;
+const comparisonSummary = (items) => ({
+    unchanged: countStatus(items, "unchanged"),
+    modified: countStatus(items, "modified"),
+    removed: countStatus(items, "removed"),
+    split: countStatus(items, "split"),
+    merged: countStatus(items, "merged"),
+    duplicated: countStatus(items, "duplicated"),
+    unknown: countStatus(items, "unknown"),
+});
+const countStatus = (items, status) => items.filter((item) => item.status === status).length;
+const coverageStatus = (factors) => {
+    if (factors.omittedSourceFiles > 0 ||
+        factors.omittedApplicationNodes > 0 ||
+        factors.omittedCandidateEvaluations > 0 ||
+        factors.omittedCandidateReferences > 0 ||
+        factors.pathIndexTruncated)
+        return "truncated";
+    return factors.input.reference.inventory_state === "complete" &&
+        factors.input.application.graph.coverage.status === "complete"
+        ? "complete-within-inputs"
+        : "partial";
+};
+const comparisonLimitations = (factors) => uniqueSorted([
+    "Static digest and location signals do not establish runtime behavior, semantic equivalence, or absence of dynamically generated modules.",
+    ...factors.input.reference.limitations,
+    ...factors.input.application.graph.limitations,
+    ...(factors.input.reference.inventory_state === "complete"
+        ? []
+        : [
+            `Historical source inventory is ${factors.input.reference.inventory_state}; unmatched files remain unknown.`,
+        ]),
+    ...(factors.input.application.graph.coverage.status === "complete"
+        ? []
+        : [
+            `Application graph coverage is ${factors.input.application.graph.coverage.status}; unmatched files remain unknown.`,
+        ]),
+    ...(factors.omittedSourceFiles > 0
+        ? [
+            `${String(factors.omittedSourceFiles)} historical source files were omitted by max_source_files.`,
+        ]
+        : []),
+    ...(factors.omittedApplicationNodes > 0
+        ? [
+            `${String(factors.omittedApplicationNodes)} source-bearing application nodes were omitted by max_application_nodes.`,
+        ]
+        : []),
+    ...(factors.omittedCandidateEvaluations > 0
+        ? [
+            `${String(factors.omittedCandidateEvaluations)} candidate evaluations were omitted by max_candidate_evaluations.`,
+        ]
+        : []),
+    ...(factors.omittedCandidateReferences > 0
+        ? [
+            `${String(factors.omittedCandidateReferences)} candidate references were omitted from item output.`,
+        ]
+        : []),
+    ...(factors.pathIndexTruncated
+        ? [
+            "At least one current path exceeded the 128-segment suffix index bound.",
+        ]
+        : []),
+]);
+const hasSignal = (candidate, kind) => candidate.signals.some((signal) => signal.kind === kind);
+const compareCandidates = (left, right) => right.score - left.score ||
+    compareText(left.current_node_id, right.current_node_id);
+const digestCanonical = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Source-to-bundle comparison could not canonicalize");
+    return createHash("sha256").update(encoded).digest("hex");
+};
+const uniqueSorted = (values) => [...new Set(values)].sort(compareText);
+const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/domain/sourceToBundleComparisonSchemas.js

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { evidenceSchema } from "./evidence.js";
+import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "./javascriptApplicationGraphSchemas.js";
+import { historicalSourceGraphSchema } from "./referenceSourceGraph.js";
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
+const boundedTextSchema = z.string().min(1).max(4_096);
+export const SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS = {
+    "exact-source-digest": 100,
+    "source-map-original-path": 70,
+    "current-path-exact": 60,
+    "current-path-suffix": 40,
+    "basename-match": 20,
+    "language-extension": 5,
+};
+const sourceToBundleSignalKindSchema = z.enum([
+    "exact-source-digest",
+    "source-map-original-path",
+    "current-path-exact",
+    "current-path-suffix",
+    "basename-match",
+    "language-extension",
+]);
+const sourceToBundleLimitsSchema = z.strictObject({
+    max_source_files: z.number().int().min(1).max(100_000).default(10_000),
+    max_application_nodes: z.number().int().min(1).max(100_000).default(20_000),
+    max_candidate_nodes: z.number().int().min(1).max(1_000).default(100),
+    max_candidate_evaluations: z
+        .number()
+        .int()
+        .min(1)
+        .max(10_000_000)
+        .default(1_000_000),
+});
+/** Historical source inventory, authenticated application Evidence, and bounds. */
+export const compareSourceToBundleInputSchema = z.strictObject({
+    reference: historicalSourceGraphSchema,
+    application: evidenceSchema,
+    limits: sourceToBundleLimitsSchema.default({
+        max_source_files: 10_000,
+        max_application_nodes: 20_000,
+        max_candidate_nodes: 100,
+        max_candidate_evaluations: 1_000_000,
+    }),
+    unknown_registry_approved: z.literal(true).optional(),
+});
+const sourceToBundleSignalSchema = z.strictObject({
+    kind: sourceToBundleSignalKindSchema,
+    weight: z.number().int().min(1).max(100),
+    source_value: boundedTextSchema,
+    current_values: z.array(boundedTextSchema).min(1).max(64),
+});
+const sourceToBundleCandidateSchema = z.strictObject({
+    current_node_id: nodeIdSchema,
+    current_node_kind: z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS),
+    score: z.number().int().min(1).max(300),
+    confidence: z.enum(["exact", "high", "medium", "low"]),
+    signals: z.array(sourceToBundleSignalSchema).min(1).max(6),
+});
+const sourceToBundleItemSchema = z.strictObject({
+    mapping_id: z.string().regex(/^stbc_item_[a-f0-9]{64}$/u),
+    source_path: boundedTextSchema,
+    source_sha256: digestSchema.nullable(),
+    source_language: z.string().min(1).max(100).nullable(),
+    status: z.enum([
+        "unchanged",
+        "modified",
+        "removed",
+        "split",
+        "merged",
+        "duplicated",
+        "unknown",
+    ]),
+    confidence: z.enum(["exact", "high", "medium", "unknown"]),
+    current_node_ids: z.array(nodeIdSchema).max(1_000),
+    candidates: z.array(sourceToBundleCandidateSchema).max(1_000),
+    omitted_candidates: z.number().int().min(0),
+    limitations: z.array(boundedTextSchema).max(100),
+});
+/** Deterministic, evidence-bearing historical-source to shipped-bundle comparison. */
+export const sourceToBundleComparisonResultSchema = z.strictObject({
+    schema_version: z.literal(1),
+    comparison_id: z.string().regex(/^stbc_[a-f0-9]{64}$/u),
+    reference: z.strictObject({
+        root_sha256: digestSchema,
+        inventory_state: z.enum(["complete", "partial", "unknown"]),
+    }),
+    application: z.strictObject({
+        evidence_id: evidenceIdSchema,
+        graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
+        root_artifact_sha256: digestSchema,
+    }),
+    scoring: z.strictObject({
+        algorithm: z.literal("rea-source-to-bundle-signals/v1"),
+        minimum_candidate_score: z.literal(20),
+        weights: z.array(z.strictObject({
+            signal: sourceToBundleSignalKindSchema,
+            weight: z.number().int().min(1).max(100),
+        })),
+    }),
+    summary: z.strictObject({
+        unchanged: z.number().int().min(0),
+        modified: z.number().int().min(0),
+        removed: z.number().int().min(0),
+        split: z.number().int().min(0),
+        merged: z.number().int().min(0),
+        duplicated: z.number().int().min(0),
+        unknown: z.number().int().min(0),
+    }),
+    items: z.array(sourceToBundleItemSchema).max(100_000),
+    unmapped_current_node_ids: z.array(nodeIdSchema).max(100_000),
+    coverage: z.strictObject({
+        status: z.enum(["complete-within-inputs", "partial", "truncated"]),
+        reference_inventory_state: z.enum(["complete", "partial", "unknown"]),
+        application_graph_status: z.enum([
+            "complete",
+            "partial",
+            "unknown",
+            "unavailable",
+        ]),
+        retained_source_files: z.number().int().min(0),
+        omitted_source_files: z.number().int().min(0),
+        retained_application_nodes: z.number().int().min(0),
+        omitted_application_nodes: z.number().int().min(0),
+        candidate_evaluations: z.number().int().min(0),
+        omitted_candidate_evaluations: z.number().int().min(0),
+        omitted_candidate_references: z.number().int().min(0),
+        omitted_unmapped_current_nodes: z.number().int().min(0),
+    }),
+    evidence_links: z.array(evidenceIdSchema).min(1).max(1),
+    limitations: z.array(boundedTextSchema).max(1_000),
+});

package/dist/domain/sourceToBundleSignals.js

@@ -0,0 +1,202 @@
+import { posix } from "node:path";
+import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, } from "./sourceToBundleComparisonSchemas.js";
+const RELEVANT_NODE_KINDS = new Set([
+    "javascript-asset",
+    "javascript-module",
+    "source-module",
+]);
+const PATH_PROPERTIES = [
+    "path",
+    "source",
+    "original_source",
+    "module_path",
+    "resolved_path",
+    "declared_path",
+];
+const MAX_PATH_SUFFIXES = 128;
+/** Keep source-bearing application nodes in stable identifier order. */
+export const sourceBearingNodes = (nodes) => nodes
+    .filter(({ kind }) => RELEVANT_NODE_KINDS.has(kind))
+    .sort((left, right) => compareText(left.node_id, right.node_id));
+/** Keep historical source files in stable path order. */
+export const historicalSourceFiles = (graph) => graph.entries
+    .filter((entry) => entry.kind === "file" && entry.classifications.includes("source"))
+    .sort((left, right) => compareText(left.path, right.path));
+/** Build bounded-key indices without assigning fuzzy matches. */
+export const buildSourceToBundleCandidateIndex = (nodes) => {
+    const projections = nodes.map(projectCurrentNode);
+    const byDigest = new Map();
+    const byPathSuffix = new Map();
+    const byBasename = new Map();
+    let pathIndexTruncated = false;
+    for (const projection of projections) {
+        for (const digest of projection.digests)
+            addIndexValue(byDigest, digest, projection.node.node_id);
+        for (const path of projection.paths) {
+            const suffixes = pathSuffixes(path.value);
+            pathIndexTruncated ||= suffixes.truncated;
+            for (const suffix of suffixes.values)
+                addIndexValue(byPathSuffix, suffix, projection.node.node_id);
+            addIndexValue(byBasename, posix.basename(path.value), projection.node.node_id);
+        }
+    }
+    return {
+        nodes: new Map(projections.map((projection) => [projection.node.node_id, projection])),
+        byDigest,
+        byPathSuffix,
+        byBasename,
+        pathIndexTruncated,
+    };
+};
+/** Candidate identifiers ordered by strongest available signal, then ID. */
+export const candidateIdsForSource = (source, index) => {
+    const groups = [
+        source.sha256 === null ? undefined : index.byDigest.get(source.sha256),
+        index.byPathSuffix.get(source.path),
+        index.byBasename.get(posix.basename(source.path)),
+    ];
+    const seen = new Set();
+    const output = [];
+    for (const group of groups) {
+        if (group === undefined)
+            continue;
+        for (const nodeId of [...group].sort(compareText)) {
+            if (seen.has(nodeId))
+                continue;
+            seen.add(nodeId);
+            output.push(nodeId);
+        }
+    }
+    return output;
+};
+/** Score one indexed candidate from explicit, caller-visible signals. */
+export const scoreSourceToBundleCandidate = (source, nodeId, index) => {
+    const projection = index.nodes.get(nodeId);
+    if (projection === undefined)
+        return null;
+    const signals = candidateSignals(source, projection);
+    const score = signals.reduce((total, signal) => total + signal.weight, 0);
+    if (score < 20)
+        return null;
+    return {
+        current_node_id: projection.node.node_id,
+        current_node_kind: projection.node.kind,
+        score,
+        confidence: candidateConfidence(signals),
+        signals,
+    };
+};
+const projectCurrentNode = (node) => {
+    const digests = new Set();
+    const paths = [];
+    if (node.identity.strategy === "content-digest")
+        digests.add(node.identity.sha256);
+    if (node.identity.strategy === "source-map-original") {
+        if (node.identity.source_sha256 !== null)
+            digests.add(node.identity.source_sha256);
+        addPath(paths, "source-map-original", node.identity.original_source);
+    }
+    if (node.identity.strategy === "canonical-path")
+        addPath(paths, "canonical-path", node.identity.path);
+    for (const observation of node.observations) {
+        const sourceDigest = observation.properties.source_sha256;
+        if (typeof sourceDigest === "string" && isDigest(sourceDigest))
+            digests.add(sourceDigest);
+        for (const key of PATH_PROPERTIES)
+            addJsonPath(paths, observation.properties[key]);
+    }
+    return {
+        node,
+        digests,
+        paths: uniquePaths(paths),
+    };
+};
+const candidateSignals = (source, current) => {
+    const signals = [];
+    if (source.sha256 !== null && current.digests.has(source.sha256))
+        signals.push(signal("exact-source-digest", source.sha256, [source.sha256]));
+    const sourceMapPaths = matchingPaths(source.path, current.paths.filter(({ kind }) => kind === "source-map-original"));
+    if (sourceMapPaths.length > 0)
+        signals.push(signal("source-map-original-path", source.path, sourceMapPaths));
+    const otherPaths = current.paths.filter(({ kind }) => kind !== "source-map-original");
+    const exactPaths = otherPaths
+        .filter(({ value }) => value === source.path)
+        .map(({ value }) => value);
+    if (exactPaths.length > 0)
+        signals.push(signal("current-path-exact", source.path, exactPaths));
+    const suffixPaths = otherPaths
+        .filter(({ value }) => value !== source.path && value.endsWith(`/${source.path}`))
+        .map(({ value }) => value);
+    if (suffixPaths.length > 0)
+        signals.push(signal("current-path-suffix", source.path, suffixPaths));
+    const basename = posix.basename(source.path);
+    const basenamePaths = current.paths
+        .filter(({ value }) => posix.basename(value) === basename)
+        .map(({ value }) => value);
+    if (basenamePaths.length > 0)
+        signals.push(signal("basename-match", basename, basenamePaths));
+    const extension = posix.extname(source.path).toLowerCase();
+    const extensionPaths = current.paths
+        .filter(({ value }) => posix.extname(value).toLowerCase() === extension)
+        .map(({ value }) => value);
+    if (extension !== "" && extensionPaths.length > 0)
+        signals.push(signal("language-extension", extension, extensionPaths));
+    return signals;
+};
+const signal = (kind, sourceValue, currentValues) => ({
+    kind,
+    weight: SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS[kind],
+    source_value: sourceValue,
+    current_values: [...new Set(currentValues)].sort(compareText).slice(0, 64),
+});
+const candidateConfidence = (signals) => {
+    const kinds = new Set(signals.map(({ kind }) => kind));
+    if (kinds.has("exact-source-digest"))
+        return "exact";
+    if (kinds.has("source-map-original-path") || kinds.has("current-path-exact"))
+        return "high";
+    return kinds.has("current-path-suffix") ? "medium" : "low";
+};
+const matchingPaths = (sourcePath, currentPaths) => currentPaths
+    .filter(({ value }) => value === sourcePath || value.endsWith(`/${sourcePath}`))
+    .map(({ value }) => value);
+const addJsonPath = (paths, value) => {
+    if (typeof value === "string")
+        addPath(paths, "observation-path", value);
+};
+const addPath = (paths, kind, raw) => {
+    const value = normalizeCurrentPath(raw);
+    if (value !== null)
+        paths.push({ kind, value });
+};
+const normalizeCurrentPath = (raw) => {
+    const withoutQuery = raw.split(/[?#]/u, 1)[0] ?? "";
+    const withoutScheme = withoutQuery.replace(/^[a-z][a-z0-9+.-]*:\/\/+/iu, "");
+    const parts = withoutScheme
+        .replaceAll("\\", "/")
+        .split("/")
+        .filter((part) => part !== "" && part !== ".");
+    if (parts.length === 0 || parts.includes(".."))
+        return null;
+    return parts.join("/");
+};
+const uniquePaths = (paths) => [
+    ...new Map(paths.map((path) => [`${path.kind}\0${path.value}`, path])).values(),
+].sort((left, right) => compareText(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
+const pathSuffixes = (path) => {
+    const parts = path.split("/");
+    const start = Math.max(0, parts.length - MAX_PATH_SUFFIXES);
+    return {
+        values: parts
+            .slice(start)
+            .map((_, index) => parts.slice(start + index).join("/")),
+        truncated: start > 0,
+    };
+};
+const addIndexValue = (index, key, nodeId) => {
+    const values = index.get(key) ?? new Set();
+    values.add(nodeId);
+    index.set(key, values);
+};
+const isDigest = (value) => /^[a-f0-9]{64}$/u.test(value);
+const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;