@memoarchitect/tools 0.13.0 → 0.15.0

package/packages/tools/lib/model/native-project.js

@@ -8,8 +8,8 @@
 // if a project still carries them. Selection now comes from two native facts:
 //
 //   1. the project's own `.sysml` import graph, rooted at the entrypoint
-//      `model/catalog/project.sysml`, and
-//   2. the `ProjectMethodBinding` that entrypoint declares, whose
+//      `model/methodology/project.sysml`, and
+//   2. the `ModelMethodBinding` that entrypoint declares, whose
 //      `selectedMethodology` is a typed SysML reference.
 //
 // Application settings still say *where* a package's source sits on disk. That
@@ -21,16 +21,16 @@
 //
 // Design reference: sections 5.1, 5.3, 6.2, 9.
 // ─────────────────────────────────────────────────────────────────────────────
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, realpathSync, lstatSync, statSync } from 'node:fs';
 import { dirname, extname, join, relative, resolve, sep } from 'node:path';
-import { parseFiles } from './parser-utils.js';
 import { readPackageManifest } from './package-manifest.js';
+import { satisfiesRange } from './version-range.js';
 import { discoverMemoManifests, findMemoManifests, resolveManifestPath } from './manifest.js';
 import { importKpar } from '../commands/package.js';
 /**
  * SysML v2 standard-library packages.
  *
- * These are supplied by the conformant tool (SysIDE, Sysand), not by a MEMO
+ * These are supplied by the selected compiler and the package manager, not by a MEMO
  * package, so an import of one resolves to nothing on disk and that is correct.
  * Reporting it as an unresolved import would bury the real diagnostics under
  * one line per file.
@@ -45,7 +45,7 @@ const STANDARD_LIBRARY_PACKAGES = new Set([
     'ISQ', 'SI', 'Quantities', 'MeasurementReferences', 'Time', 'SpatialFrames',
 ]);
 /** Conventional template value for the required project root descriptor. */
-export const PROJECT_ENTRYPOINT = join('model', 'catalog', 'project.sysml');
+export const PROJECT_ENTRYPOINT = join('model', 'methodology', 'project.sysml');
 /**
  * Resolve the project's required native entrypoint. `entrypoint` is a project locator:
  * it names the SysML file from which project identity and import scope start;
@@ -53,7 +53,7 @@ export const PROJECT_ENTRYPOINT = join('model', 'catalog', 'project.sysml');
  *
  * There is NO conventional fallback. A project without an `entrypoint` in its
  * `memo.package.yaml` is not a project, even if a file happens to sit at
- * `model/catalog/project.sysml` — that path is a scaffolding default, not a
+ * `model/methodology/project.sysml` — that path is a scaffolding default, not a
  * location the resolver assumes. Callers must report the missing locator
  * rather than a missing file, because the file is usually there.
  */
@@ -69,13 +69,30 @@ export function projectEntrypoint(projectRoot) {
         return configured;
     return relative(root, candidate);
 }
+/** The project's method binding, read from SysML. */
+/**
+ * The definitions a model's method binding is typed by. `ModelMethodBinding`
+ * is the name; `ProjectMethodBinding` is its deprecated former spelling (a
+ * specialization of it in the ontology), still read so an existing model binds,
+ * and reported by `deprecated-binding-spelling`. Every place that recognizes a
+ * binding asks this list, so the old spelling is named in one place.
+ * Delete `ProjectMethodBinding` in 0.15.0.
+ */
+export const METHOD_BINDING_KINDS = ['ModelMethodBinding', 'ProjectMethodBinding'];
+/** The spellings of a binding that are deprecated: its old type and its old name attribute. */
+export const DEPRECATED_BINDING_SPELLINGS = { kind: 'ProjectMethodBinding', name: 'projectName' };
+export function isMethodBindingKind(kind) {
+    return METHOD_BINDING_KINDS.includes(kind ?? '');
+}
 // ─── Project root ─────────────────────────────────────────────────────────────
 /**
  * Find the project root by walking up for a root descriptor whose explicit
  * `entrypoint` names an existing SysML root file.
  */
 export function findProjectRoot(startDir) {
-    let dir = resolve(startDir);
+    // A real path, so every caller that names files from the root names them as
+    // a compiler does (see `canonicalPath`).
+    let dir = canonicalPath(startDir);
     while (true) {
         const entrypoint = projectEntrypoint(dir);
         if (entrypoint && existsSync(join(dir, entrypoint)))
@@ -86,6 +103,28 @@ export function findProjectRoot(startDir) {
         dir = parent;
     }
 }
+/**
+ * The real path of a directory, symbolic links resolved. A compiler names the
+ * files it read by their real paths; a project reached through a symlink (macOS
+ * `/tmp` and `/var`, a linked home) would otherwise never match them, and
+ * resolve to nothing.
+ */
+function isSymlink(path) {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function canonicalPath(path) {
+    try {
+        return realpathSync.native(resolve(path));
+    }
+    catch {
+        return resolve(path);
+    }
+}
 // ─── Library roots (locators only) ────────────────────────────────────────────
 /**
  * Collect the library roots a project could resolve packages from.
@@ -94,10 +133,13 @@ export function findProjectRoot(startDir) {
  * closure decides what is *selected*. A root listed here and never imported
  * contributes nothing to the model.
  */
-export function discoverLibraryRoots(projectRoot) {
+export function discoverLibraryRoots(projectRoot, onShadowed) {
     const roots = new Map();
     const add = (dir) => {
-        const abs = resolve(dir);
+        // The real path: a package installed by symlink (`memo install <path>`) is
+        // reported by the compiler at the directory the link points to, and the
+        // root must be known by that name for its files to be matched to it.
+        const abs = isSymlink(dir) ? canonicalPath(dir) : resolve(dir);
         if (roots.has(abs))
             return;
         const { path, manifest } = readPackageManifest(abs);
@@ -106,12 +148,21 @@ export function discoverLibraryRoots(projectRoot) {
         const sysmlDir = manifest.sysmlDir ? resolve(abs, manifest.sysmlDir) : abs;
         if (!existsSync(sysmlDir))
             return;
-        roots.set(abs, {
+        const root = {
             dir: abs,
             sysmlDir,
             packageName: manifest.name ?? abs.split(sep).pop() ?? abs,
             packageVersion: manifest.version,
-        });
+        };
+        // A package name resolves to one root. Two copies of one package declare every package in it twice,
+        // so the first found keeps the name: an explicit override, then the nearest repository, then the
+        // installation. The ones passed over are reported, never merged.
+        const kept = [...roots.values()].find(candidate => candidate.packageName === root.packageName);
+        if (kept) {
+            onShadowed?.(kept, root);
+            return;
+        }
+        roots.set(abs, root);
     };
     // Distribution manifests map a package name to a directory. They are an
     // application/distribution setting: they make a package available, they do
@@ -123,7 +174,7 @@ export function discoverLibraryRoots(projectRoot) {
         // Extensions are reusable ontology packages, so they are library roots
         // on the same terms as any other package: available, not selected.
         // They were reachable only as example directories before, which meant
-        // a project could import an extension, resolve it under `syside`, and
+        // a project could import an extension, resolve it under an external compiler, and
         // still have every extension type come back unregistered — no layer,
         // no supertype, no legality. Listing them here is what makes an
         // extension mean something to the tools and not just to the compiler.
@@ -175,228 +226,6 @@ export function discoverLibraryRoots(projectRoot) {
     }
     return [...roots.values()];
 }
-// ─── AST reading ──────────────────────────────────────────────────────────────
-function attrString(value) {
-    if (!value)
-        return undefined;
-    switch (value.$type) {
-        case 'StringValue':
-            try {
-                return JSON.parse(value.value ?? '""');
-            }
-            catch {
-                return value.value?.replace(/^"|"$/g, '');
-            }
-        case 'IntValue':
-        case 'RealValue':
-        case 'BooleanValue':
-            return String(value.value);
-        case 'EnumValue': {
-            const ref = value.enumRef ?? '';
-            const idx = ref.lastIndexOf('::');
-            return idx >= 0 ? ref.slice(idx + 2) : ref;
-        }
-        case 'SetLiteral':
-            return undefined; // handled by attrList
-        default:
-            return undefined;
-    }
-}
-/**
- * Read a list-valued attribute.
- *
- * SysML spells a multi-valued attribute either as a set literal
- * (`= ("a", "b")`) or as repeated single assignments. Both are read here so the
- * ontology's authoring style is not a semantic difference.
- */
-function attrList(body, name) {
-    const out = [];
-    for (const member of body ?? []) {
-        if (member.$type !== 'AttributeMember' || member.name !== name || !member.value)
-            continue;
-        if (member.value.$type === 'SetLiteral') {
-            // A SetElement is either a quoted string or a qualified name; the
-            // grammar puts them in different properties.
-            for (const el of member.value.elements ?? []) {
-                const raw = el.stringValue ?? el.value;
-                if (typeof raw === 'string') {
-                    try {
-                        out.push(JSON.parse(raw));
-                    }
-                    catch {
-                        out.push(stripQuotes(raw));
-                    }
-                }
-            }
-        }
-        else {
-            const v = attrString(member.value);
-            if (v !== undefined)
-                out.push(v);
-        }
-    }
-    return out;
-}
-function stripQuotes(s) {
-    return s.replace(/^"|"$/g, '');
-}
-function attr(body, name) {
-    for (const member of body ?? []) {
-        if (member.$type === 'AttributeMember' && member.name === name && member.value) {
-            const v = attrString(member.value);
-            if (v !== undefined)
-                return v;
-        }
-    }
-    return undefined;
-}
-/**
- * Read the type a `ref :>> <name> : <Type>;` member narrows to.
- *
- * This is the reference mechanism session 1 verified across the MEMO grammar,
- * SysIDE, and Sysand: narrowing the reference's type names the rule, because
- * each rule is its own `constraint def`. Binding a *value* to a definition is
- * not portable — SysIDE rejects it, since a value must be a feature.
- */
-function refType(body, name) {
-    for (const member of body ?? []) {
-        if (member.$type !== 'RefMember' || member.name !== name)
-            continue;
-        if (member.type)
-            return shortName(member.type);
-        if (member.value)
-            return attrString(member.value);
-    }
-    return undefined;
-}
-function shortName(qualified) {
-    const idx = qualified.lastIndexOf('::');
-    return idx >= 0 ? qualified.slice(idx + 2) : qualified;
-}
-function asScopeMode(raw) {
-    return raw === 'allAvailable' || raw === 'explicit' ? raw : undefined;
-}
-function readRulePolicy(node, file) {
-    const body = node.body ?? [];
-    const disposition = attr(body, 'disposition');
-    const severity = attr(body, 'severityOverride');
-    return {
-        usageName: node.name,
-        targetRuleType: refType(body, 'targetRule'),
-        replacementRuleType: refType(body, 'replacementRule'),
-        disposition: disposition === 'enabled' || disposition === 'disabled' || disposition === 'replaced'
-            ? disposition
-            : undefined,
-        severityOverride: severity === 'error' || severity === 'warning' || severity === 'info' ? severity : undefined,
-        rationaleText: attr(body, 'rationaleText'),
-        authority: attr(body, 'authority'),
-        approvalReference: attr(body, 'approvalReference'),
-        approvedBy: attr(body, 'approvedBy'),
-        approvedOn: attr(body, 'approvedOn'),
-        sourceFile: file,
-    };
-}
-function nestedPolicies(node, file) {
-    const out = [];
-    for (const member of node.body ?? []) {
-        if (member.$type === 'PartMember' && member.type && shortName(member.type) === 'RulePolicy') {
-            out.push(readRulePolicy(member, file));
-        }
-    }
-    return out;
-}
-/** Walk one document for `ProjectMethodBinding` and `MethodologyDefinition` usages. */
-function readNativeUsages(doc) {
-    const bindings = [];
-    const methodologies = [];
-    const model = doc.document.parseResult?.value;
-    if (!model)
-        return { bindings, methodologies };
-    const visit = (node, pkg) => {
-        if (!node)
-            return;
-        if (node.$type === 'PackageDeclaration') {
-            for (const m of node.members ?? [])
-                visit(m, node.name ?? pkg);
-            return;
-        }
-        if (node.$type !== 'PartUsage' && node.$type !== 'PartMember')
-            return;
-        const type = node.type ? shortName(node.type) : undefined;
-        const body = node.body ?? [];
-        if (type === 'ProjectMethodBinding') {
-            bindings.push({
-                usageName: node.name,
-                bindingId: attr(body, 'id'),
-                projectName: attr(body, 'projectName'),
-                selectedMethodologyName: refType(body, 'selectedMethodology'),
-                scopeMode: asScopeMode(attr(body, 'scopeMode')),
-                includedModules: attrList(body, 'includedModule'),
-                rulePolicies: nestedPolicies(node, doc.filePath),
-                sourceFile: doc.filePath,
-                packageQualifiedName: pkg,
-            });
-        }
-        else if (type === 'MethodologyDefinition') {
-            methodologies.push({
-                usageName: node.name,
-                methodologyId: attr(body, 'id'),
-                displayName: attr(body, 'name'),
-                version: attr(body, 'version'),
-                baseMethodologyName: refType(body, 'baseMethodology'),
-                scopeMode: asScopeMode(attr(body, 'scopeMode')),
-                includedLayers: attrList(body, 'includedLayer'),
-                includedModules: attrList(body, 'includedModule'),
-                includedStandards: attrList(body, 'includedStandard'),
-                includedArtifactKinds: attrList(body, 'includedArtifactKind'),
-                includedViewpoints: attrList(body, 'includedViewpoint'),
-                rulePolicies: nestedPolicies(node, doc.filePath),
-                sourceFile: doc.filePath,
-                packageQualifiedName: pkg,
-            });
-        }
-        for (const m of body)
-            visit(m, pkg);
-    };
-    for (const member of model.members ?? [])
-        visit(member);
-    return { bindings, methodologies };
-}
-function indexPackages(documents, fileToRoot) {
-    const index = new Map();
-    for (const doc of documents) {
-        const model = doc.document.parseResult?.value;
-        if (!model)
-            continue;
-        const walk = (node) => {
-            if (!node || node.$type !== 'PackageDeclaration')
-                return;
-            const name = node.name;
-            let entry = index.get(name);
-            if (!entry) {
-                entry = { qualifiedName: name, files: new Set(), imports: new Set(), root: fileToRoot.get(doc.filePath) };
-                index.set(name, entry);
-            }
-            entry.files.add(doc.filePath);
-            if (!entry.root)
-                entry.root = fileToRoot.get(doc.filePath);
-            for (const member of node.members ?? []) {
-                if (member.$type === 'ImportDeclaration') {
-                    const path = member.path ?? '';
-                    const pkgName = path.endsWith('::*') ? path.slice(0, -3) : path.split('::').slice(0, -1).join('::') || path;
-                    if (pkgName)
-                        entry.imports.add(pkgName);
-                }
-                else {
-                    walk(member);
-                }
-            }
-        };
-        for (const member of model.members ?? [])
-            walk(member);
-    }
-    return index;
-}
 function collectSysmlFiles(dir, out = []) {
     let entries = [];
     try {
@@ -432,24 +261,51 @@ function collectSysmlFiles(dir, out = []) {
  * Before the flip this read `type:` out of the package manifest; that field is
  * gone, so a reusable root is classified by whether it supplies a methodology.
  */
-function originFor(root, suppliesMethodology) {
+function originFor(root, suppliesMethodology, dependencyDirs = new Set()) {
     if (!root)
         return 'project';
     if (suppliesMethodology)
         return 'methodology';
+    // A root the project's `dependencies` name is a model it builds on, not the
+    // ontology: the consumer says which packages are models, and the import
+    // closure still decides which of their packages are used.
+    if (dependencyDirs.has(root.dir))
+        return 'dependency';
     return 'ontology';
 }
-// ─── Resolution ───────────────────────────────────────────────────────────────
 /**
- * Resolve a project from its native SysML alone.
- *
- * The closure walk starts at the entrypoint's package and follows imports.
- * Anything it does not reach is not part of the model, however many manifests
- * point at it.
+ * Match each `dependencies` entry to a library root by name (a scoped name also
+ * matches its bare form, the way `memo install` stores a directory), and say
+ * which are missing or at a version the range does not accept.
  */
-export async function resolveNativeProject(projectRoot) {
+export function resolveDependencies(projectRoot, libraryRoots, diagnostics) {
+    const declared = readPackageManifest(projectRoot).manifest.dependencies ?? {};
+    const bare = (name) => name.replace(/^@[^/]+\//, '');
+    const out = [];
+    for (const [name, range] of Object.entries(declared)) {
+        const root = libraryRoots.find(r => r.packageName === name)
+            ?? libraryRoots.find(r => bare(r.packageName) === bare(name));
+        out.push({ name, range, root });
+        if (!root) {
+            diagnostics.push({
+                code: 'dependency-missing',
+                message: `The dependency "${name}" (${range}) is listed in memo.package.yaml but no package of that name was found. `
+                    + 'Install it with `memo-architect install`, or place it under memo_packages/.',
+            });
+        }
+        else if (!satisfiesRange(root.packageVersion, range)) {
+            diagnostics.push({
+                code: 'dependency-version',
+                message: `The dependency "${name}" asks for ${range} and ${root.dir} is ${root.packageVersion ?? 'unversioned'}.`,
+            });
+        }
+    }
+    return out;
+}
+/** Find a project's sources: no SysML is read. */
+export function discoverProjectSources(projectRoot) {
     const diagnostics = [];
-    const root = resolve(projectRoot);
+    const root = canonicalPath(projectRoot);
     const entrypointPath = projectEntrypoint(root);
     const entrypoint = entrypointPath ? resolve(root, entrypointPath) : undefined;
     const includes = readPackageManifest(root).manifest.include ?? [];
@@ -473,9 +329,20 @@ export async function resolveNativeProject(projectRoot) {
             });
         }
     }
-    const libraryRoots = discoverLibraryRoots(root);
+    const shadowed = [];
+    const libraryRoots = discoverLibraryRoots(root, (kept, ignored) => shadowed.push({ kept, ignored }));
+    if (shadowed.length > 0) {
+        const names = shadowed.map(s => s.ignored.packageName);
+        diagnostics.push({
+            code: 'library-root-shadowed',
+            severity: 'warning',
+            message: `${names.length} package(s) were found in two places and the first is used: ${names.slice(0, 3).join(', ')}${names.length > 3 ? ', …' : ''}. `
+                + `Using ${dirname(shadowed[0].kept.dir)}, not ${dirname(shadowed[0].ignored.dir)}. The order is MEMO_ONTOLOGY_PATH, then the nearest repository, then the installation; `
+                + 'two copies would declare every package twice.',
+        });
+    }
     const fileToRoot = new Map();
-    // Match SysIDE's source-root contract exactly: only explicitly included
+    // Match the `include` source-root contract exactly: only explicitly included
     // directories are project model source. Includes may name a sibling OTS
     // repository; imports, rather than physical location, decide scope.
     const projectFiles = [...new Set(includes.filter(include => extname(include).toLowerCase() !== '.kpar').flatMap(include => {
@@ -493,8 +360,16 @@ export async function resolveNativeProject(projectRoot) {
             libraryFiles.push(f);
         }
     }
-    const parsed = await parseFiles([...projectFiles, ...libraryFiles], '');
-    const documents = parsed.documents;
+    return { projectRoot: root, entrypointPath, entrypoint, libraryRoots, projectFiles, libraryFiles, fileToRoot, diagnostics };
+}
+/**
+ * Close a project's resolution over its package index and native usages,
+ * however they were read: the import closure from the entrypoint, the library
+ * roots it selects, and the method binding.
+ */
+export function finishResolution(sources, index, bindings, methodologyList) {
+    const { projectRoot: root, entrypointPath, entrypoint, libraryRoots } = sources;
+    const diagnostics = [...sources.diagnostics];
     if (!entrypoint || !existsSync(entrypoint)) {
         diagnostics.push({
             code: 'no-entrypoint',
@@ -503,11 +378,12 @@ export async function resolveNativeProject(projectRoot) {
             file: entrypoint,
         });
     }
-    const index = indexPackages(documents, fileToRoot);
     const filePackages = new Map();
+    const publicImports = new Map();
     for (const entry of index.values()) {
         for (const file of entry.files)
             filePackages.set(file, entry.qualifiedName);
+        publicImports.set(entry.qualifiedName, entry.publicImports);
     }
     // The entrypoint, not every source file on disk, starts the closure. This
     // keeps an unimported source area out of explicit scope and makes the same
@@ -518,17 +394,24 @@ export async function resolveNativeProject(projectRoot) {
         if (entrypoint && entry.files.has(entrypoint))
             queue.push({ name: entry.qualifiedName, depth: 0 });
     }
+    if (entrypoint && existsSync(entrypoint) && queue.length === 0) {
+        // The entrypoint is on disk and nothing that was compiled declares it, so
+        // the project resolves to nothing. Said, not left as an empty model.
+        diagnostics.push({
+            code: 'entrypoint-not-compiled',
+            message: `No compiled document declares the entrypoint ${entrypoint}, so nothing of the project could be resolved. `
+                + 'A project reached through a symbolic link is the usual cause: open it by its real path.',
+            file: entrypoint,
+        });
+    }
+    const dependencies = resolveDependencies(root, libraryRoots, diagnostics);
+    const dependencyDirs = new Set(dependencies.flatMap(d => d.root ? [d.root.dir] : []));
     const methodologyPackages = new Set();
-    const bindings = [];
     const methodologies = new Map();
-    for (const doc of documents) {
-        const { bindings: b, methodologies: m } = readNativeUsages(doc);
-        bindings.push(...b);
-        for (const meth of m) {
-            methodologies.set(meth.usageName, meth);
-            if (meth.packageQualifiedName)
-                methodologyPackages.add(meth.packageQualifiedName);
-        }
+    for (const meth of methodologyList) {
+        methodologies.set(meth.usageName, meth);
+        if (meth.packageQualifiedName)
+            methodologyPackages.add(meth.packageQualifiedName);
     }
     while (queue.length > 0) {
         const { name, depth, via } = queue.shift();
@@ -554,7 +437,7 @@ export async function resolveNativeProject(projectRoot) {
             qualifiedName: name,
             files: [...entry.files],
             root: entry.root,
-            origin: originFor(entry.root, methodologyPackages.has(name)),
+            origin: originFor(entry.root, methodologyPackages.has(name), dependencyDirs),
             importDepth: depth,
             importedBy: via ? [via] : [],
         });
@@ -572,8 +455,8 @@ export async function resolveNativeProject(projectRoot) {
         if (entrypoint && existsSync(entrypoint)) {
             diagnostics.push({
                 code: 'no-binding',
-                message: `No ProjectMethodBinding found in ${entrypointPath}. It must declare one; `
-                    + `it is what selects the project's methodology.`,
+                message: `No ModelMethodBinding found in ${entrypointPath}. It must declare one; `
+                    + `it is what selects the model's methodology.`,
                 file: entrypoint,
             });
         }
@@ -581,15 +464,24 @@ export async function resolveNativeProject(projectRoot) {
     else if (projectBindings.length > 1) {
         diagnostics.push({
             code: 'multiple-bindings',
-            message: `${projectBindings.length} ProjectMethodBinding usages found (`
+            message: `${projectBindings.length} ModelMethodBinding usages found (`
                 + projectBindings.map(b => `${b.usageName} in ${relative(root, b.sourceFile)}`).join(', ')
-                + `). A project binds exactly one methodology; which one applied would otherwise depend on load order.`,
+                + `). A model binds exactly one methodology; which one applied would otherwise depend on load order.`,
         });
         binding = projectBindings[0];
     }
     else {
         binding = projectBindings[0];
     }
+    if (binding?.deprecatedSpellings?.length) {
+        diagnostics.push({
+            code: 'deprecated-binding-spelling',
+            severity: 'warning',
+            message: `${binding.usageName} is written with ${binding.deprecatedSpellings.map(s => `\`${s}\``).join(' and ')}, `
+                + 'which still work and are deleted in 0.15.0. Write `ModelMethodBinding` and `modelName` instead.',
+            file: binding.sourceFile,
+        });
+    }
     if (binding) {
         if (!binding.selectedMethodologyName) {
             diagnostics.push({
@@ -606,11 +498,14 @@ export async function resolveNativeProject(projectRoot) {
                 file: binding.sourceFile,
             });
         }
-        if (binding.scopeMode === 'allAvailable' && binding.includedModules.length > 0) {
+        const imported = binding.packageQualifiedName
+            ? [...(publicImports.get(binding.packageQualifiedName) ?? [])] : [];
+        if (binding.scopeMode === 'allAvailable' && imported.length > 0) {
             diagnostics.push({
                 code: 'scope-mode-conflict',
-                message: `${binding.usageName} sets scopeMode = allAvailable and also lists includedModule entries. `
-                    + `Under allAvailable the lists must be empty, or the binding states its scope twice.`,
+                message: `${binding.usageName} sets scopeMode = allAvailable, and its package also publicly imports `
+                    + `${imported.join(', ')} to add to the selection. `
+                    + `Under allAvailable everything resolved is selected, so the binding states its scope twice.`,
                 file: binding.sourceFile,
             });
         }
@@ -623,8 +518,9 @@ export async function resolveNativeProject(projectRoot) {
         closure,
         selectedRoots,
         unusedRoots,
-        documents,
+        dependencies,
         filePackages,
+        publicImports,
         diagnostics,
     };
 }