context-probe 0.1.0

package/dist/src/analyzers/architecture-telemetry-normalization-band.d.ts

@@ -0,0 +1,10 @@
+import type { ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetryObservationSet, ArchitectureTelemetryRawObservationSet } from "../core/contracts.js";
+import type { NormalizedTelemetryResult, TelemetryNormalizationFinding } from "./architecture-telemetry-normalization-shared.js";
+export declare function buildEmptyTelemetryNormalizationResult(unknown: string, confidence: number, findings: TelemetryNormalizationFinding[], rawBands?: ArchitectureTelemetryRawObservationSet["bands"]): NormalizedTelemetryResult;
+export declare function normalizeTelemetryBand(input: {
+    band: ArchitectureTelemetryRawObservationSet["bands"][number];
+    profile: ArchitectureTelemetryNormalizationProfile;
+    findings: TelemetryNormalizationFinding[];
+    unknowns: string[];
+}): ArchitectureTelemetryObservationSet["bands"][number];
+export declare function countNormalizedTelemetryBand(band: ArchitectureTelemetryObservationSet["bands"][number]): number;

package/dist/src/analyzers/architecture-telemetry-normalization-band.js

@@ -0,0 +1,78 @@
+import { normalizeObservedValue } from "./architecture-observation-normalization-shared.js";
+import { buildTelemetryBandMappings } from "./architecture-telemetry-normalization-spec.js";
+export function buildEmptyTelemetryNormalizationResult(unknown, confidence, findings, rawBands = []) {
+    return {
+        telemetry: {
+            version: "1.0",
+            bands: rawBands.map((band) => ({
+                bandId: band.bandId,
+                trafficWeight: band.trafficWeight,
+            })),
+        },
+        confidence,
+        unknowns: [unknown],
+        findings,
+    };
+}
+export function normalizeTelemetryBand(input) {
+    const { band, profile, findings, unknowns } = input;
+    const normalizedBand = {
+        bandId: band.bandId,
+        trafficWeight: band.trafficWeight,
+    };
+    const mappings = buildTelemetryBandMappings({ band, profile });
+    for (const mapping of mappings) {
+        if (!mapping.rule) {
+            unknowns.push(`${band.bandId} is missing a normalization rule for ${mapping.component}.`);
+            findings.push({
+                kind: "missing_normalization_rule",
+                bandId: band.bandId,
+                component: mapping.component,
+                confidence: 0.58,
+                note: `${band.bandId} has no rule to normalize ${mapping.component}.`,
+            });
+            continue;
+        }
+        if (mapping.observed === undefined) {
+            unknowns.push(`${band.bandId} is missing the raw ${mapping.component} signal.`);
+            findings.push({
+                kind: "missing_raw_signal",
+                bandId: band.bandId,
+                component: mapping.component,
+                confidence: 0.62,
+                note: `${band.bandId} is missing the raw ${mapping.component} signal.`,
+            });
+            continue;
+        }
+        const normalized = normalizeObservedValue({
+            direction: mapping.rule.direction,
+            observed: mapping.observed,
+            target: mapping.rule.target,
+            worstAcceptable: mapping.rule.worstAcceptable,
+        });
+        normalizedBand[mapping.component] = normalized;
+        findings.push({
+            kind: "normalized_signal",
+            bandId: band.bandId,
+            component: mapping.component,
+            observed: mapping.observed,
+            normalized,
+            confidence: 0.86,
+            note: `${band.bandId} normalized ${mapping.component} from raw telemetry to ${normalized.toFixed(3)}.`,
+        });
+    }
+    return normalizedBand;
+}
+export function countNormalizedTelemetryBand(band) {
+    let count = 0;
+    if (band.LatencyScore !== undefined) {
+        count += 1;
+    }
+    if (band.ErrorScore !== undefined) {
+        count += 1;
+    }
+    if (band.SaturationScore !== undefined) {
+        count += 1;
+    }
+    return count;
+}

package/dist/src/analyzers/architecture-telemetry-normalization-core.d.ts

@@ -0,0 +1,6 @@
+import type { ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetryRawObservationSet } from "../core/contracts.js";
+import type { NormalizedTelemetryResult } from "./architecture-telemetry-normalization-shared.js";
+export declare function normalizeTelemetryObservationsCore(input: {
+    raw?: ArchitectureTelemetryRawObservationSet;
+    profile?: ArchitectureTelemetryNormalizationProfile;
+}): NormalizedTelemetryResult;

package/dist/src/analyzers/architecture-telemetry-normalization-core.js

@@ -0,0 +1,30 @@
+import { average, clamp01, uniqueUnknowns } from "./architecture-observation-normalization-shared.js";
+import { buildEmptyTelemetryNormalizationResult, countNormalizedTelemetryBand, normalizeTelemetryBand, } from "./architecture-telemetry-normalization-band.js";
+export function normalizeTelemetryObservationsCore(input) {
+    const findings = [];
+    const unknowns = [];
+    const rawBands = input.raw?.bands ?? [];
+    const profile = input.profile;
+    if (rawBands.length === 0) {
+        return buildEmptyTelemetryNormalizationResult("No telemetry raw observations were provided, so raw normalization is unobserved.", 0.25, findings);
+    }
+    if (!profile) {
+        return buildEmptyTelemetryNormalizationResult("No telemetry normalization profile was provided, so raw telemetry cannot be scored.", 0.3, findings, rawBands);
+    }
+    const normalizedBands = rawBands.map((band) => normalizeTelemetryBand({ band, profile, findings, unknowns }));
+    const observedSignals = normalizedBands.reduce((total, band) => total + countNormalizedTelemetryBand(band), 0);
+    const totalPossibleSignals = Math.max(1, rawBands.length * 3);
+    return {
+        telemetry: {
+            version: "1.0",
+            bands: normalizedBands,
+        },
+        confidence: clamp01(average([
+            rawBands.length > 0 ? 0.82 : 0.25,
+            Object.keys(profile.signals).length > 0 ? 0.84 : 0.35,
+            observedSignals / totalPossibleSignals,
+        ], 0.35)),
+        unknowns: uniqueUnknowns(unknowns),
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-telemetry-normalization-shared.d.ts

@@ -0,0 +1,16 @@
+import type { ArchitectureTelemetryObservationSet } from "../core/contracts.js";
+export interface TelemetryNormalizationFinding {
+    kind: "normalized_signal" | "missing_raw_signal" | "missing_normalization_rule";
+    confidence: number;
+    note: string;
+    bandId: string;
+    component: "LatencyScore" | "ErrorScore" | "SaturationScore";
+    observed?: number;
+    normalized?: number;
+}
+export interface NormalizedTelemetryResult {
+    telemetry: ArchitectureTelemetryObservationSet;
+    confidence: number;
+    unknowns: string[];
+    findings: TelemetryNormalizationFinding[];
+}

package/dist/src/analyzers/architecture-telemetry-normalization-shared.js

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

package/dist/src/analyzers/architecture-telemetry-normalization-spec.d.ts

@@ -0,0 +1,10 @@
+import type { ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetryRawObservationSet } from "../core/contracts.js";
+export interface TelemetryBandMapping {
+    component: "LatencyScore" | "ErrorScore" | "SaturationScore";
+    observed: number | undefined;
+    rule: ArchitectureTelemetryNormalizationProfile["signals"][keyof ArchitectureTelemetryNormalizationProfile["signals"]] | undefined;
+}
+export declare function buildTelemetryBandMappings(input: {
+    band: ArchitectureTelemetryRawObservationSet["bands"][number];
+    profile: ArchitectureTelemetryNormalizationProfile;
+}): TelemetryBandMapping[];

package/dist/src/analyzers/architecture-telemetry-normalization-spec.js

@@ -0,0 +1,20 @@
+export function buildTelemetryBandMappings(input) {
+    const { band, profile } = input;
+    return [
+        {
+            component: "LatencyScore",
+            observed: band.latencyP95,
+            rule: profile.signals.LatencyScore,
+        },
+        {
+            component: "ErrorScore",
+            observed: band.errorRate,
+            rule: profile.signals.ErrorScore,
+        },
+        {
+            component: "SaturationScore",
+            observed: band.saturationRatio,
+            rule: profile.signals.SaturationScore,
+        },
+    ];
+}

package/dist/src/analyzers/architecture-telemetry-normalization.d.ts

@@ -0,0 +1,6 @@
+import type { ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetryRawObservationSet } from "../core/contracts.js";
+export type { NormalizedTelemetryResult, TelemetryNormalizationFinding, } from "./architecture-telemetry-normalization-shared.js";
+export declare function normalizeTelemetryObservations(input: {
+    raw?: ArchitectureTelemetryRawObservationSet;
+    profile?: ArchitectureTelemetryNormalizationProfile;
+}): import("./architecture-telemetry-normalization-shared.js").NormalizedTelemetryResult;

package/dist/src/analyzers/architecture-telemetry-normalization.js

@@ -0,0 +1,4 @@
+import { normalizeTelemetryObservationsCore } from "./architecture-telemetry-normalization-core.js";
+export function normalizeTelemetryObservations(input) {
+    return normalizeTelemetryObservationsCore(input);
+}

package/dist/src/analyzers/architecture-topology-core.d.ts

@@ -0,0 +1,7 @@
+import type { ArchitectureTopologyModel, TopologyRuntimeObservationSet } from "../core/contracts.js";
+import { scoreTopologyIsolation as analyzeTopologyIsolation } from "./architecture-topology-signals.js";
+export type { TopologyIsolationFinding, TopologyIsolationScore } from "./architecture-topology-signals.js";
+export declare function scoreTopologyIsolation(input: {
+    topology?: ArchitectureTopologyModel;
+    observations?: TopologyRuntimeObservationSet;
+}): ReturnType<typeof analyzeTopologyIsolation>;

package/dist/src/analyzers/architecture-topology-core.js

@@ -0,0 +1,4 @@
+import { scoreTopologyIsolation as analyzeTopologyIsolation } from "./architecture-topology-signals.js";
+export function scoreTopologyIsolation(input) {
+    return analyzeTopologyIsolation(input);
+}

package/dist/src/analyzers/architecture-topology-shared.d.ts

@@ -0,0 +1,2 @@
+export declare function clamp01(value: number): number;
+export declare function average(values: number[], fallback: number): number;

package/dist/src/analyzers/architecture-topology-shared.js

@@ -0,0 +1,9 @@
+export function clamp01(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+export function average(values, fallback) {
+    if (values.length === 0) {
+        return fallback;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}

package/dist/src/analyzers/architecture-topology-signals.d.ts

@@ -0,0 +1,21 @@
+import type { ArchitectureTopologyModel, TopologyRuntimeObservationSet } from "../core/contracts.js";
+export interface TopologyIsolationFinding {
+    kind: "shared_dependency" | "weak_failure_isolation" | "weak_runtime_containment";
+    nodeId?: string;
+    source?: string;
+    target?: string;
+    confidence: number;
+    note: string;
+}
+export interface TopologyIsolationScore {
+    FI: number;
+    RC: number;
+    SDR: number;
+    confidence: number;
+    unknowns: string[];
+    findings: TopologyIsolationFinding[];
+}
+export declare function scoreTopologyIsolation(input: {
+    topology?: ArchitectureTopologyModel;
+    observations?: TopologyRuntimeObservationSet;
+}): TopologyIsolationScore;

package/dist/src/analyzers/architecture-topology-signals.js

@@ -0,0 +1,98 @@
+import { average, clamp01 } from "./architecture-topology-shared.js";
+export function scoreTopologyIsolation(input) {
+    const topology = input.topology;
+    const observations = input.observations?.observations ?? [];
+    if (!topology || topology.nodes.length === 0) {
+        return {
+            FI: 0.4,
+            RC: 0.4,
+            SDR: 0.6,
+            confidence: 0.25,
+            unknowns: ["No topology model was provided, so TIS is close to unobserved."],
+            findings: [],
+        };
+    }
+    const findings = [];
+    const unknowns = [];
+    const nodeById = new Map(topology.nodes.map((node) => [node.nodeId, node]));
+    const sharedEdges = topology.edges.filter((edge) => edge.shared || edge.kind === "shared_resource");
+    const syncEdges = topology.edges.filter((edge) => edge.kind === "sync_call");
+    const crossBoundarySyncEdges = syncEdges.filter((edge) => {
+        const sourceBoundary = nodeById.get(edge.source)?.isolationBoundary;
+        const targetBoundary = nodeById.get(edge.target)?.isolationBoundary;
+        return Boolean(sourceBoundary && targetBoundary && sourceBoundary !== targetBoundary);
+    });
+    const SDR = topology.edges.length === 0 ? 0 : sharedEdges.length / topology.edges.length;
+    if (sharedEdges.length === 0) {
+        unknowns.push("No shared resources were observed, so SDR evidence is limited.");
+    }
+    findings.push(...sharedEdges.map((edge) => ({
+        kind: "shared_dependency",
+        source: edge.source,
+        target: edge.target,
+        confidence: 0.86,
+        note: `There is a shared dependency between ${edge.source} and ${edge.target}.`,
+    })));
+    const staticFi = clamp01(1 - crossBoundarySyncEdges.length / Math.max(1, syncEdges.length || 1));
+    const runtimeFiSignals = observations
+        .map((entry) => entry.failureContainmentRatio)
+        .filter((value) => value !== undefined);
+    const FI = runtimeFiSignals.length > 0
+        ? average(runtimeFiSignals.map((value) => clamp01(value)), staticFi)
+        : staticFi;
+    if (runtimeFiSignals.length === 0) {
+        unknowns.push("Runtime observations for failure containment are missing, so FI is using a static proxy.");
+    }
+    findings.push(...crossBoundarySyncEdges.map((edge) => ({
+        kind: "weak_failure_isolation",
+        source: edge.source,
+        target: edge.target,
+        confidence: 0.8,
+        note: `The synchronous dependency from ${edge.source} to ${edge.target} crosses an isolation boundary.`,
+    })));
+    const boundaryNodeCounts = new Map();
+    for (const node of topology.nodes) {
+        const boundary = node.isolationBoundary;
+        if (!boundary) {
+            continue;
+        }
+        boundaryNodeCounts.set(boundary, (boundaryNodeCounts.get(boundary) ?? 0) + 1);
+    }
+    const maxBoundarySize = boundaryNodeCounts.size === 0 ? topology.nodes.length : Math.max(...boundaryNodeCounts.values());
+    const staticRc = clamp01(1 - (maxBoundarySize - 1) / Math.max(1, topology.nodes.length - 1 || 1));
+    const runtimeRcSignals = observations
+        .map((entry) => entry.runtimeContainment)
+        .filter((value) => value !== undefined);
+    const RC = runtimeRcSignals.length > 0
+        ? average(runtimeRcSignals.map((value) => clamp01(value)), staticRc)
+        : staticRc;
+    if (runtimeRcSignals.length === 0) {
+        unknowns.push("Runtime containment observations are missing, so RC is using a static proxy.");
+    }
+    for (const [boundary, count] of boundaryNodeCounts.entries()) {
+        if (count <= Math.ceil(topology.nodes.length / 2)) {
+            continue;
+        }
+        findings.push({
+            kind: "weak_runtime_containment",
+            nodeId: boundary,
+            confidence: 0.72,
+            note: `Nodes are concentrated in ${boundary}, so runtime containment may be weak.`,
+        });
+    }
+    if (topology.nodes.every((node) => !node.isolationBoundary)) {
+        unknowns.push("Very few isolation boundaries are defined, so FI/RC evidence is limited.");
+    }
+    return {
+        FI,
+        RC,
+        SDR,
+        confidence: clamp01(average([
+            topology.nodes.length > 0 ? 0.82 : 0.25,
+            topology.edges.length > 0 ? 0.8 : 0.4,
+            observations.length > 0 ? 0.86 : 0.55,
+        ], 0.45)),
+        unknowns: Array.from(new Set(unknowns)),
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-topology.d.ts

@@ -0,0 +1,2 @@
+export type { TopologyIsolationFinding, TopologyIsolationScore } from "./architecture-topology-core.js";
+export { scoreTopologyIsolation } from "./architecture-topology-core.js";

package/dist/src/analyzers/architecture-topology.js

@@ -0,0 +1 @@
+export { scoreTopologyIsolation } from "./architecture-topology-core.js";

package/dist/src/analyzers/architecture.d.ts

@@ -0,0 +1,16 @@
+import type { ArchitectureConstraints, CodebaseAnalysis } from "../core/contracts.js";
+export interface DirectionViolation {
+    source: string;
+    target: string;
+    sourceLayer: string;
+    targetLayer: string;
+}
+export interface DependencyDirectionScore {
+    IDR: number;
+    LRC: number;
+    APM: number;
+    applicableEdges: number;
+    violations: DirectionViolation[];
+}
+export declare function detectDirectionViolations(codebase: CodebaseAnalysis, constraints: ArchitectureConstraints): DirectionViolation[];
+export declare function scoreDependencyDirection(codebase: CodebaseAnalysis, constraints: ArchitectureConstraints): DependencyDirectionScore;

package/dist/src/analyzers/architecture.js

@@ -0,0 +1,44 @@
+import { matchGlobs } from "../core/io.js";
+import { getScorableDependencies } from "./code.js";
+function classifyLayer(filePath, constraints) {
+    return constraints.layers.find((layer) => matchGlobs(filePath, layer.globs));
+}
+export function detectDirectionViolations(codebase, constraints) {
+    const violations = [];
+    for (const dependency of getScorableDependencies(codebase).filter((entry) => entry.targetKind === "file")) {
+        const sourceLayer = classifyLayer(dependency.source, constraints);
+        const targetLayer = classifyLayer(dependency.target, constraints);
+        if (!sourceLayer || !targetLayer) {
+            continue;
+        }
+        if (sourceLayer.rank < targetLayer.rank) {
+            violations.push({
+                source: dependency.source,
+                target: dependency.target,
+                sourceLayer: sourceLayer.name,
+                targetLayer: targetLayer.name,
+            });
+        }
+    }
+    return violations;
+}
+export function scoreDependencyDirection(codebase, constraints) {
+    const scorableDependencies = getScorableDependencies(codebase);
+    const classifiedEdges = scorableDependencies.filter((entry) => {
+        if (entry.targetKind !== "file") {
+            return false;
+        }
+        return Boolean(classifyLayer(entry.source, constraints) && classifyLayer(entry.target, constraints));
+    });
+    const violations = detectDirectionViolations(codebase, constraints);
+    const applicableEdges = classifiedEdges.length;
+    const illegalRatio = applicableEdges === 0 ? 0 : violations.length / applicableEdges;
+    const classifiedCoverage = scorableDependencies.length === 0 ? 0 : Math.min(1, applicableEdges / scorableDependencies.length);
+    return {
+        IDR: illegalRatio,
+        LRC: 1 - illegalRatio,
+        APM: classifiedCoverage,
+        applicableEdges,
+        violations,
+    };
+}

package/dist/src/analyzers/code-contracts.d.ts

@@ -0,0 +1,4 @@
+import type { BoundaryLeakFinding, CodebaseAnalysis, ContractUsageReport, DomainModel, FileDependency } from "../core/contracts.js";
+export declare function getScorableDependencies(codebase: CodebaseAnalysis): FileDependency[];
+export declare function detectContractUsage(codebase: CodebaseAnalysis, model: DomainModel): ContractUsageReport;
+export declare function detectBoundaryLeaks(codebase: CodebaseAnalysis, model: DomainModel): BoundaryLeakFinding[];

package/dist/src/analyzers/code-contracts.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+import { matchGlobs } from "../core/io.js";
+export function getScorableDependencies(codebase) {
+    const scorableSources = new Set(codebase.scorableSourceFiles);
+    return codebase.dependencies.filter((dependency) => scorableSources.has(dependency.source));
+}
+function classifyContext(filePath, model) {
+    for (const context of model.contexts) {
+        if (!matchGlobs(filePath, context.pathGlobs)) {
+            continue;
+        }
+        if (matchGlobs(filePath, context.contractGlobs)) {
+            return { context: context.name, classification: "contract" };
+        }
+        if (matchGlobs(filePath, context.internalGlobs)) {
+            return { context: context.name, classification: "internal" };
+        }
+        return { context: context.name, classification: "unclassified" };
+    }
+    return { classification: "unclassified" };
+}
+export function detectContractUsage(codebase, model) {
+    let applicableReferences = 0;
+    let compliantReferences = 0;
+    const findings = [];
+    for (const dependency of getScorableDependencies(codebase).filter((entry) => entry.targetKind === "file")) {
+        const sourceInfo = classifyContext(dependency.source, model);
+        const targetInfo = classifyContext(dependency.target, model);
+        if (!sourceInfo.context || !targetInfo.context || sourceInfo.context === targetInfo.context) {
+            continue;
+        }
+        applicableReferences += 1;
+        if (targetInfo.classification === "contract") {
+            compliantReferences += 1;
+        }
+        findings.push({
+            source: dependency.source,
+            target: dependency.target,
+            sourceContext: sourceInfo.context,
+            targetContext: targetInfo.context,
+            targetClassification: targetInfo.classification,
+        });
+    }
+    return {
+        adherence: applicableReferences === 0 ? 1 : compliantReferences / applicableReferences,
+        applicableReferences,
+        compliantReferences,
+        findings,
+    };
+}
+export function detectBoundaryLeaks(codebase, model) {
+    const findings = [];
+    for (const dependency of getScorableDependencies(codebase).filter((entry) => entry.targetKind === "file")) {
+        const sourceInfo = classifyContext(dependency.source, model);
+        const targetInfo = classifyContext(dependency.target, model);
+        if (!sourceInfo.context || !targetInfo.context || sourceInfo.context === targetInfo.context) {
+            continue;
+        }
+        if (targetInfo.classification !== "internal") {
+            continue;
+        }
+        findings.push({
+            findingId: `BL-${dependency.source.replace(/[^A-Za-z0-9]/g, "").slice(-8)}-${findings.length + 1}`,
+            severity: "high",
+            sourceContext: sourceInfo.context,
+            targetContext: targetInfo.context,
+            violationType: "direct_internal_type_reference",
+            sourceSymbol: path.basename(dependency.source),
+            targetSymbol: path.basename(dependency.target),
+            path: dependency.source,
+        });
+    }
+    return findings;
+}

package/dist/src/analyzers/code-dart.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSourceFile } from "../core/contracts.js";
+import { type DartPackageContext } from "./code-shared.js";
+export declare function parseDartSourceFile(root: string, absolutePath: string, relative: string, source: string, packageContext: DartPackageContext): ParsedSourceFile;

package/dist/src/analyzers/code-dart.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { DART_DIRECTIVE_PATTERN, DART_PART_OF_PATTERN, isGeneratedDartFile, resolveWithCandidates, stripComments, } from "./code-shared.js";
+function resolveDartModule(root, fromFile, specifier, packageContext) {
+    if (specifier.startsWith("dart:")) {
+        return { target: specifier, targetKind: "external" };
+    }
+    if (specifier.startsWith("package:")) {
+        const packageMatch = /^package:([^/]+)\/(.+)$/.exec(specifier);
+        if (!packageMatch) {
+            return { target: specifier, targetKind: "external" };
+        }
+        const [, packageName, packagePath] = packageMatch;
+        if (!packageName ||
+            !packagePath ||
+            !packageContext.packageName ||
+            packageContext.packageName !== packageName ||
+            !packageContext.packageRoot) {
+            return { target: specifier, targetKind: "external" };
+        }
+        const packageBase = path.join(packageContext.packageRoot, packagePath);
+        const candidates = path.extname(packageBase) ? [packageBase] : [packageBase, `${packageBase}.dart`];
+        return resolveWithCandidates(root, specifier, candidates);
+    }
+    if (specifier.includes(":")) {
+        return { target: specifier, targetKind: "external" };
+    }
+    const absoluteBase = path.resolve(path.dirname(fromFile), specifier);
+    const candidates = path.extname(absoluteBase) ? [absoluteBase] : [absoluteBase, `${absoluteBase}.dart`];
+    return resolveWithCandidates(root, specifier, candidates);
+}
+export function parseDartSourceFile(root, absolutePath, relative, source, packageContext) {
+    const sanitized = stripComments(source);
+    const imports = [];
+    const libraryRole = DART_PART_OF_PATTERN.test(sanitized) ? "part" : "library";
+    for (const match of sanitized.matchAll(DART_DIRECTIVE_PATTERN)) {
+        const directive = match[1];
+        const specifier = match[2];
+        if (!directive || !specifier) {
+            continue;
+        }
+        const resolved = resolveDartModule(root, absolutePath, specifier, packageContext);
+        imports.push({
+            source: relative,
+            target: resolved.target,
+            specifier,
+            targetKind: resolved.targetKind,
+            kind: directive,
+        });
+    }
+    return {
+        path: relative,
+        imports,
+        language: "dart",
+        generated: isGeneratedDartFile(relative) || libraryRole === "part",
+        libraryRole,
+    };
+}

package/dist/src/analyzers/code-ecma.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedSourceFile } from "../core/contracts.js";
+export declare function parseEcmaSourceFile(root: string, absolutePath: string, relative: string, source: string): ParsedSourceFile;

package/dist/src/analyzers/code-ecma.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import ts from "typescript";
+import { inferSourceLanguage, resolveWithCandidates } from "./code-shared.js";
+function resolveEcmaModule(root, fromFile, specifier) {
+    if (!specifier.startsWith(".")) {
+        return { target: specifier, targetKind: "external" };
+    }
+    const absoluteBase = path.resolve(path.dirname(fromFile), specifier);
+    const extension = path.extname(absoluteBase).toLowerCase();
+    const withoutExtension = extension ? absoluteBase.slice(0, -extension.length) : absoluteBase;
+    const candidates = [
+        absoluteBase,
+        `${absoluteBase}.ts`,
+        `${absoluteBase}.tsx`,
+        `${absoluteBase}.js`,
+        `${absoluteBase}.jsx`,
+        path.join(absoluteBase, "index.ts"),
+        path.join(absoluteBase, "index.tsx"),
+        path.join(absoluteBase, "index.js"),
+        path.join(absoluteBase, "index.jsx"),
+    ];
+    if (extension === ".js" || extension === ".jsx" || extension === ".mjs" || extension === ".cjs") {
+        candidates.push(`${withoutExtension}.ts`, `${withoutExtension}.tsx`, `${withoutExtension}.mts`, `${withoutExtension}.cts`, path.join(withoutExtension, "index.ts"), path.join(withoutExtension, "index.tsx"), path.join(withoutExtension, "index.mts"), path.join(withoutExtension, "index.cts"));
+    }
+    return resolveWithCandidates(root, specifier, candidates);
+}
+export function parseEcmaSourceFile(root, absolutePath, relative, source) {
+    const sourceFile = ts.createSourceFile(relative, source, ts.ScriptTarget.ES2022, true);
+    const imports = [];
+    sourceFile.forEachChild((node) => {
+        if (!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node)) {
+            return;
+        }
+        if (!node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) {
+            return;
+        }
+        const specifier = node.moduleSpecifier.text;
+        const resolved = resolveEcmaModule(root, absolutePath, specifier);
+        imports.push({
+            source: relative,
+            target: resolved.target,
+            specifier,
+            targetKind: resolved.targetKind,
+            kind: ts.isImportDeclaration(node) ? "import" : "export",
+        });
+    });
+    return {
+        path: relative,
+        imports,
+        language: inferSourceLanguage(relative),
+        generated: false,
+    };
+}

package/dist/src/analyzers/code-shared.d.ts

@@ -0,0 +1,19 @@
+import type { FileDependency, ParsedSourceFile } from "../core/contracts.js";
+export declare const ECMASCRIPT_EXTENSIONS: Set<string>;
+export declare const DART_EXTENSION = ".dart";
+export declare const DART_DIRECTIVE_PATTERN: RegExp;
+export declare const DART_PART_OF_PATTERN: RegExp;
+export interface ResolveResult {
+    target: string;
+    targetKind: FileDependency["targetKind"];
+}
+export interface DartPackageContext {
+    packageName?: string;
+    packageRoot?: string;
+}
+export declare function isDartSourceFile(filePath: string): boolean;
+export declare function inferSourceLanguage(filePath: string): ParsedSourceFile["language"];
+export declare function isGeneratedDartFile(filePath: string): boolean;
+export declare function stripComments(source: string): string;
+export declare function resolveWithCandidates(root: string, specifier: string, candidates: string[]): ResolveResult;
+export declare function loadDartPackageContext(root: string): Promise<DartPackageContext>;