reverseport 0.0.0-stage → 1.2.0

package/dist/domain/javascript/javascriptSymbolicControlFlow.js

@@ -0,0 +1,40 @@
+import * as t from "@babel/types";
+import { symbolicTruth, } from "./javascriptSymbolicValues.js";
+/** Whether short-circuit evaluation reaches the right operand; unknown stays unknown. */
+export const symbolicLogicalRight = (operator, left) => {
+    if (left.kind === "union") {
+        const choices = left.values.map((value) => symbolicLogicalRight(operator, value));
+        return choices.length > 0 &&
+            choices.every((choice) => choice === choices[0])
+            ? choices[0]
+            : undefined;
+    }
+    if (operator === "??") {
+        if (left.kind === "literal")
+            return left.value === null || left.value === undefined;
+        return [
+            "function",
+            "object",
+            "namespace",
+            "array",
+            "record",
+            "loader",
+        ].includes(left.kind)
+            ? false
+            : undefined;
+    }
+    const truth = symbolicTruth(left);
+    return truth === undefined ? undefined : operator === "&&" ? truth : !truth;
+};
+/** Only definite synchronous exits; unsupported control flow stays unknown. */
+export const symbolicDefiniteExit = (node, depth = 0) => {
+    if (!node || depth >= 128)
+        return false;
+    if (t.isReturnStatement(node) || t.isThrowStatement(node))
+        return true;
+    if (t.isBlockStatement(node))
+        return node.body.some((child) => symbolicDefiniteExit(child, depth + 1));
+    return (t.isIfStatement(node) &&
+        symbolicDefiniteExit(node.consequent, depth + 1) &&
+        symbolicDefiniteExit(node.alternate, depth + 1));
+};

package/dist/domain/javascript/javascriptSymbolicValues.js

@@ -0,0 +1,34 @@
+export const symbolicUnknown = (reason) => ({
+    kind: "unknown",
+    reason,
+});
+export const symbolicVariants = (value) => value.kind === "union" ? value.values : [value];
+export const symbolicUnion = (values) => {
+    const unique = [...new Set(values.flatMap(symbolicVariants))];
+    return unique.length === 1 ? unique[0] : { kind: "union", values: unique };
+};
+export const symbolicTruth = (value) => {
+    if (value.kind === "union") {
+        const choices = value.values.map(symbolicTruth);
+        return choices.length > 0 &&
+            choices.every((choice) => choice === choices[0])
+            ? choices[0]
+            : undefined;
+    }
+    return value.kind === "literal"
+        ? Boolean(value.value)
+        : ["function", "object", "namespace", "array", "record", "loader"].includes(value.kind)
+            ? true
+            : undefined;
+};
+/** Attach selection predicates to values while preserving their representation. */
+export const symbolicCondition = (value, condition) => {
+    if (value.kind === "union")
+        return symbolicUnion(value.values.map((variant) => symbolicCondition(variant, condition)));
+    return { ...value, conditions: [...(value.conditions ?? []), condition] };
+};
+export const symbolicConditionsUnresolved = (value) => {
+    if (value.kind === "union")
+        return symbolicUnion(value.values.map(symbolicConditionsUnresolved));
+    return { ...value, conditionUnresolved: true };
+};

package/dist/domain/javascript/sourceToBundleComparison.js

@@ -0,0 +1,261 @@
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { absenceClaimable } from "../comparisonSemantics.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
+import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, sourceToBundleComparisonResultSchema, } from "./sourceToBundleComparisonSchemas.js";
+import { buildSourceToBundleCandidateIndex, candidateHasDigest, 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,
+    };
+    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 = {
+        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_${digestCanonicalValue(semanticResult, "Source-to-bundle comparison")}`,
+    });
+};
+const projectComparison = (input) => {
+    const allSources = historicalSourceFiles(input.reference);
+    const allCurrentNodes = sourceBearingNodes(input.application.graph.nodes);
+    const sources = allSources;
+    const currentNodes = allCurrentNodes;
+    const index = buildSourceToBundleCandidateIndex(currentNodes);
+    return {
+        sources,
+        currentNodes,
+        index,
+        absenceComplete: input.reference.inventory_state === "complete" &&
+            absenceClaimable(input.application.graph.coverage),
+        factors: {
+            input,
+        },
+    };
+};
+const compareMappings = (input, projection) => {
+    let candidateEvaluations = 0;
+    const provisionalItems = [];
+    for (const source of projection.sources) {
+        const candidateIds = candidateIdsForSource(source, projection.index);
+        candidateEvaluations += candidateIds.length;
+        const scored = candidateIds
+            .map((nodeId) => scoreSourceToBundleCandidate(source, nodeId, projection.index))
+            .filter((candidate) => candidate !== null)
+            .sort(compareCandidates);
+        const classification = classifyMapping(scored, projection.absenceComplete, (nodeId) => source.sha256 !== null && candidateHasDigest(projection.index, nodeId));
+        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: scored,
+            limitations: uniqueSorted([
+                ...source.limitations,
+                ...classification.limitations,
+            ]),
+        };
+        provisionalItems.push({
+            mapping_id: mappingId(input, semantic),
+            ...semantic,
+        });
+    }
+    return {
+        items: markMergedMappings(input, provisionalItems),
+        candidateEvaluations,
+    };
+};
+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,
+    retained_application_nodes: projection.currentNodes.length,
+    candidate_evaluations: mappings.candidateEvaluations,
+});
+const scoringModel = () => ({
+    algorithm: "rea-source-to-bundle-signals",
+    minimum_candidate_score: 20,
+    weights: SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.map(([signal, weight]) => ({
+        signal,
+        weight,
+    })),
+});
+const classifyMapping = (candidates, absenceComplete, digestComparable) => {
+    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];
+        if (candidate !== undefined && digestComparable(candidate.current_node_id))
+            return {
+                status: "modified",
+                confidence: candidate.confidence === "high" ? "high" : "medium",
+                currentNodeIds: [candidate.current_node_id],
+                limitations: [
+                    "Location evidence links the source to the current node, but their source digests differ.",
+                ],
+            };
+        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_${digestCanonicalValue({
+    reference_root_sha256: input.reference.root_sha256,
+    application_graph_id: input.application.graph.graph_id,
+    ...item,
+}, "Source-to-bundle comparison")}`;
+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) => {
+    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.`,
+        ]),
+]);
+const hasSignal = (candidate, kind) => candidate.signals.some((signal) => signal.kind === kind);
+const compareCandidates = (left, right) => right.score - left.score ||
+    compareUnicodeCodePoints(left.current_node_id, right.current_node_id);

package/dist/domain/javascript/sourceToBundleComparisonSchemas.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { evidenceSchema } from "../evidence.js";
+import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "./javascriptApplicationGraphSchemas.js";
+import { historicalSourceGraphSchema } from "../referenceSourceGraph.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
+const nodeIdSchema = prefixedDigestSchema("jag_node");
+const textSchema = z.string().min(1);
+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",
+]);
+/** Historical source inventory and authenticated application Evidence. */
+export const compareSourceToBundleInputSchema = z.strictObject({
+    reference: historicalSourceGraphSchema,
+    application: evidenceSchema,
+});
+const sourceToBundleSignalSchema = z.strictObject({
+    kind: sourceToBundleSignalKindSchema,
+    weight: z.number().int().min(1).max(100),
+    source_value: textSchema,
+    current_values: z.array(textSchema).min(1),
+});
+const sourceToBundleCandidateSchema = z.strictObject({
+    current_node_id: nodeIdSchema,
+    current_node_kind: z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS),
+    score: z.number().int().min(1),
+    confidence: z.enum(["exact", "high", "medium", "low"]),
+    signals: z.array(sourceToBundleSignalSchema).min(1),
+});
+const sourceToBundleItemSchema = z.strictObject({
+    mapping_id: prefixedDigestSchema("stbc_item"),
+    source_path: textSchema,
+    source_sha256: digestSchema.nullable(),
+    source_language: textSchema.nullable(),
+    status: z.enum([
+        "unchanged",
+        "modified",
+        "removed",
+        "split",
+        "merged",
+        "duplicated",
+        "unknown",
+    ]),
+    confidence: z.enum(["exact", "high", "medium", "unknown"]),
+    current_node_ids: z.array(nodeIdSchema),
+    candidates: z.array(sourceToBundleCandidateSchema),
+    limitations: z.array(textSchema),
+});
+/** Deterministic, evidence-bearing historical-source to shipped-bundle comparison. */
+export const sourceToBundleComparisonResultSchema = z.strictObject({
+    comparison_id: prefixedDigestSchema("stbc"),
+    reference: z.strictObject({
+        root_sha256: digestSchema,
+        inventory_state: z.enum(["complete", "partial", "unknown"]),
+    }),
+    application: z.strictObject({
+        evidence_id: evidenceIdSchema,
+        graph_id: prefixedDigestSchema("jag"),
+        root_artifact_sha256: digestSchema,
+    }),
+    scoring: z.strictObject({
+        algorithm: z.literal("rea-source-to-bundle-signals"),
+        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),
+    unmapped_current_node_ids: z.array(nodeIdSchema),
+    coverage: z.strictObject({
+        status: z.enum(["complete-within-inputs", "partial"]),
+        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),
+        retained_application_nodes: z.number().int().min(0),
+        candidate_evaluations: z.number().int().min(0),
+    }),
+    evidence_links: z.array(evidenceIdSchema).length(1),
+    limitations: z.array(textSchema),
+});

package/dist/domain/javascript/sourceToBundleSignals.js

@@ -0,0 +1,231 @@
+import { posix } from "node:path";
+import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
+import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, } from "./sourceToBundleComparisonSchemas.js";
+import { isDigest } from "../digests.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 signalWeight = (kind) => {
+    const entry = SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.find(([signal]) => signal === kind);
+    if (entry === undefined)
+        throw new TypeError(`Missing source-to-bundle signal weight: ${kind}`);
+    return entry[1];
+};
+/** Keep source-bearing application nodes in stable identifier order. */
+export const sourceBearingNodes = (nodes) => nodes
+    .filter(({ kind }) => RELEVANT_NODE_KINDS.has(kind))
+    .sort((left, right) => compareUnicodeCodePoints(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) => compareUnicodeCodePoints(left.path, right.path));
+/** Build deterministic candidate 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();
+    for (const projection of projections) {
+        for (const digest of projection.digests)
+            addIndexValue(byDigest, digest, projection.node.node_id);
+        for (const path of projection.paths) {
+            for (const suffix of path.allowSuffix
+                ? pathSuffixes(path.value)
+                : [path.value])
+                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,
+    };
+};
+/** 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(compareUnicodeCodePoints)) {
+            if (seen.has(nodeId))
+                continue;
+            seen.add(nodeId);
+            output.push(nodeId);
+        }
+    }
+    return output;
+};
+/** Whether an indexed candidate carries any content digest to compare. */
+export const candidateHasDigest = (index, nodeId) => (index.nodes.get(nodeId)?.digests.size ?? 0) > 0;
+/** 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);
+    }
+    if (node.identity.strategy === "canonical-path")
+        addPath(paths, "canonical-path", node.identity.path);
+    for (const observation of node.observations) {
+        if (node.identity.strategy === "source-map-original") {
+            const resolution = observation.source_map_reference?.resolution;
+            if (resolution !== undefined && resolution.kind !== "unresolved")
+                paths.push({
+                    kind: "source-map-original",
+                    value: resolution.path,
+                    allowSuffix: resolution.kind === "suffix",
+                });
+        }
+        else {
+            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, allowSuffix }) => allowSuffix &&
+        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: signalWeight(kind),
+    source_value: sourceValue,
+    current_values: [...new Set(currentValues)].sort(compareUnicodeCodePoints),
+});
+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, allowSuffix }) => value === sourcePath ||
+    (allowSuffix && 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, allowSuffix: true });
+};
+const SCHEME_URL = /^[a-z][a-z0-9+.-]*:\/\//iu;
+const SCHEME_URL_PREFIX = /^[a-z][a-z0-9+.-]*:\/\/+/iu;
+const normalizeCurrentPath = (raw) => {
+    const withoutQuery = SCHEME_URL.test(raw)
+        ? (raw.split(/[?#]/u, 1)[0] ?? "")
+        : raw;
+    const portable = withoutQuery
+        .replace(SCHEME_URL_PREFIX, "")
+        .replaceAll("\\", "/");
+    const parts = [];
+    for (const part of portable.split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..") {
+            if (parts.length === 0)
+                return null;
+            parts.pop();
+        }
+        else
+            parts.push(part);
+    }
+    if (parts.length === 0)
+        return null;
+    return parts.join("/");
+};
+const uniquePaths = (paths) => [
+    ...new Map(paths.map((path) => [
+        compositeKey([path.kind, path.value, String(path.allowSuffix)]),
+        path,
+    ])).values(),
+].sort((left, right) => compareUnicodeCodePoints(compositeKey([left.kind, left.value]), compositeKey([right.kind, right.value])));
+const pathSuffixes = (path) => {
+    const parts = path.split("/");
+    return parts.map((_, index) => parts.slice(index).join("/"));
+};
+const addIndexValue = (index, key, nodeId) => {
+    const values = index.get(key) ?? new Set();
+    values.add(nodeId);
+    index.set(key, values);
+};