@rsdk/yarn.constraints 6.0.0-next.4 → 6.0.0-next.41

package/__tests__/engine.test.ts

@@ -0,0 +1,1107 @@
+import {
+  deriveDependencyModel,
+  type DependencyModelFacts,
+  type WorkspaceFacts,
+  type UsageSummary,
+} from '../src/dependency-model';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeRoot(pkg?: WorkspaceFacts['pkg']): WorkspaceFacts {
+  return {
+    name: '@test/root',
+    location: '.',
+    pkg: pkg ?? {
+      name: '@test/root',
+      private: true,
+    },
+    role: undefined,
+    isRoot: true,
+    sourceUsage: new Map(),
+    dtsImports: new Set(),
+    hasSrc: false,
+    hasDist: false,
+  };
+}
+
+function makeWorkspace(
+  name: string,
+  location: string,
+  role: WorkspaceFacts['role'],
+  pkg?: WorkspaceFacts['pkg'],
+  sourceUsage: Map<string, UsageSummary> = new Map(),
+  dtsImports: Set<string> = new Set(),
+  hasSrc = false,
+  hasDist = false,
+  sourceFileCount?: number,
+): WorkspaceFacts {
+  const basePkg: WorkspaceFacts['pkg'] = { name };
+  if (role !== undefined) basePkg.role = role;
+  return {
+    name,
+    location,
+    pkg: pkg ?? basePkg,
+    role,
+    isRoot: false,
+    sourceUsage,
+    dtsImports,
+    hasSrc,
+    hasDist,
+    ...(sourceFileCount === undefined ? {} : { sourceFileCount }),
+  };
+}
+
+function runtimeUsage(files: string[]): UsageSummary {
+  return {
+    files: new Set(files),
+    runtimeFiles: new Set(files),
+    typeOnlyFiles: new Set(),
+  };
+}
+
+function typeOnlyUsage(files: string[]): UsageSummary {
+  return {
+    files: new Set(files),
+    runtimeFiles: new Set(),
+    typeOnlyFiles: new Set(files),
+  };
+}
+
+function emptyFacts(workspaces: WorkspaceFacts[], rules: DependencyModelFacts['rules'] = []): DependencyModelFacts {
+  return {
+    workspaces,
+    externalPeerMetadata: new Map(),
+    rules,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('deriveDependencyModel engine', () => {
+  // 1. root-shape
+  describe('root-shape', () => {
+    it('reports root-private when root lacks private: true', () => {
+      const root = makeRoot({ name: '@test/root' }); // no private field
+      const facts = emptyFacts([root]);
+      const result = deriveDependencyModel(facts);
+      expect(result.violations.some((v) => v.code === 'root-private')).toBe(true);
+    });
+
+    it('reports root-section when root has dependencies section', () => {
+      const root = makeRoot({
+        name: '@test/root',
+        private: true,
+        dependencies: { lodash: '^4.0.0' },
+      });
+      const facts = emptyFacts([root]);
+      const result = deriveDependencyModel(facts);
+      expect(result.violations.some((v) => v.code === 'root-section')).toBe(true);
+    });
+
+    it('preserves root devDependencies as the shared dev baseline', () => {
+      const root = makeRoot({
+        name: '@test/root',
+        private: true,
+        devDependencies: { typescript: '5.7.3' },
+      });
+      const result = deriveDependencyModel(emptyFacts([root]));
+      const exp = result.expected.get('.')!;
+
+      expect(exp.sections.devDependencies.get('typescript')).toBe('5.7.3');
+      expect(
+        result.violations.some((v) => v.dependency === 'typescript'),
+      ).toBe(false);
+    });
+  });
+
+  // 2. role-required
+  describe('role-required', () => {
+    it('reports role-missing when workspace has no role field', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace('@test/noop', 'packages/noop', undefined, { name: '@test/noop' });
+      const facts = emptyFacts([root, ws]);
+      const result = deriveDependencyModel(facts);
+      expect(result.violations.some((v) => v.code === 'role-missing' && v.workspaceLocation === 'packages/noop')).toBe(true);
+    });
+
+    it('reports role-invalid when workspace role is unrecognised', () => {
+      const root = makeRoot();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const ws = makeWorkspace('@test/noop', 'packages/noop', undefined, { name: '@test/noop', role: 'invalid' as any });
+      const facts = emptyFacts([root, ws]);
+      const result = deriveDependencyModel(facts);
+      expect(result.violations.some((v) => v.code === 'role-invalid')).toBe(true);
+    });
+  });
+
+  // 3. library-external-default-peer: engine puts runtime import in peerDependencies
+  describe('library-external-default-peer', () => {
+    it('places runtime-imported external dep in peerDependencies for library', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([['lodash', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'lodash', version: '^4.17.21' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+      expect(exp.sections.peerDependencies.get('lodash')).toBe('^4.17.21');
+      expect(exp.sections.devDependencies.get('lodash')).toBe('^4.17.21'); // mirror
+      expect(exp.sections.dependencies.has('lodash')).toBe(false);
+    });
+  });
+
+  // 4. library-implementation-override: rule forces section: dependencies
+  describe('library-implementation-override', () => {
+    it('respects section:dependencies rule override for library', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([['some-lib', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'some-lib', section: 'dependencies', version: '1.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+      expect(exp.sections.dependencies.get('some-lib')).toBe('1.0.0');
+      expect(exp.sections.peerDependencies.has('some-lib')).toBe(false);
+      expect(exp.sections.devDependencies.has('some-lib')).toBe(false);
+    });
+
+    it(
+      'reports stale peerDependenciesMeta when a rule moves a peer to dependencies',
+      () => {
+        const root = makeRoot();
+        const ws = makeWorkspace(
+          '@test/lib',
+          'packages/lib',
+          'library',
+          {
+            name: '@test/lib',
+            role: 'library',
+            dependencies: { 'some-lib': '1.0.0' },
+            peerDependenciesMeta: { 'some-lib': { optional: true } },
+          },
+          new Map([['some-lib', runtimeUsage(['src/index.ts'])]]),
+        );
+        const facts = emptyFacts([root, ws], [
+          { match: 'some-lib', section: 'dependencies', version: '1.0.0' },
+        ]);
+        const result = deriveDependencyModel(facts);
+
+        expect(
+          result.violations.some(
+            (v) => v.code === 'stale' && v.dependency === 'some-lib',
+          ),
+        ).toBe(true);
+      },
+    );
+  });
+
+  // 5. service-runtime-deps
+  describe('service-runtime-deps', () => {
+    it('places runtime-imported external dep in dependencies for service', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        undefined,
+        new Map([['express', runtimeUsage(['src/main.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'express', version: '^4.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/svc')!;
+      expect(exp.sections.dependencies.get('express')).toBe('^4.0.0');
+      expect(exp.sections.peerDependencies.has('express')).toBe(false);
+      expect(exp.sections.devDependencies.has('express')).toBe(false);
+    });
+  });
+
+  describe('declaration-independent-expected-graph', () => {
+    it('reports a stale workspace dependency when it is declared but unused', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        {
+          name: '@test/svc',
+          role: 'service',
+          dependencies: { lodash: '^4.17.21' },
+        },
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws], [
+        { match: 'lodash', version: '^4.17.21' },
+      ]));
+
+      expect(
+        result.violations.some(
+          (v) => v.code === 'stale' && v.dependency === 'lodash',
+        ),
+      ).toBe(true);
+    });
+
+    it('keeps an unused declared dependency when a rule marks it required', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        {
+          name: '@test/svc',
+          role: 'service',
+          dependencies: { 'indirect-runtime': '^1.0.0' },
+        },
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws], [
+        { match: 'indirect-runtime', version: '^1.0.0', required: true },
+      ]));
+      const exp = result.expected.get('packages/svc')!;
+
+      expect(exp.sections.dependencies.get('indirect-runtime')).toBe('^1.0.0');
+      expect(
+        result.violations.some(
+          (v) => v.code === 'stale' && v.dependency === 'indirect-runtime',
+        ),
+      ).toBe(false);
+    });
+
+    it('applies required rules only to matching workspaces', () => {
+      const root = makeRoot();
+      const fastify = makeWorkspace(
+        '@test/fastify',
+        'packages/fastify',
+        'library',
+        {
+          name: '@test/fastify',
+          role: 'library',
+          dependencies: { '@fastify/static': '^6.12.0' },
+        },
+      );
+      const other = makeWorkspace(
+        '@test/other',
+        'packages/other',
+        'library',
+        {
+          name: '@test/other',
+          role: 'library',
+          dependencies: { '@fastify/static': '^6.12.0' },
+        },
+      );
+      const result = deriveDependencyModel(emptyFacts([root, fastify, other], [
+        {
+          match: '@fastify/static',
+          workspace: '@test/fastify',
+          section: 'dependencies',
+          version: '^6.12.0',
+          required: true,
+        },
+      ]));
+      const exp = result.expected.get('packages/fastify')!;
+
+      expect(exp.sections.dependencies.get('@fastify/static')).toBe('^6.12.0');
+      expect(exp.sections.peerDependencies.has('@fastify/static')).toBe(false);
+      expect(exp.sections.devDependencies.has('@fastify/static')).toBe(false);
+      expect(
+        result.violations.some(
+          (v) =>
+            v.workspace === '@test/other' &&
+            v.code === 'stale' &&
+            v.dependency === '@fastify/static',
+        ),
+      ).toBe(true);
+    });
+
+    it('moves a wrong-section dependency only when usage requires it', () => {
+      const root = makeRoot();
+      const used = makeWorkspace(
+        '@test/used',
+        'packages/used',
+        'service',
+        {
+          name: '@test/used',
+          role: 'service',
+          devDependencies: { express: '^4.0.0' },
+        },
+        new Map([['express', runtimeUsage(['src/main.ts'])]]),
+      );
+      const unused = makeWorkspace(
+        '@test/unused',
+        'packages/unused',
+        'service',
+        {
+          name: '@test/unused',
+          role: 'service',
+          devDependencies: { express: '^4.0.0' },
+        },
+      );
+      const result = deriveDependencyModel(emptyFacts([root, used, unused], [
+        { match: 'express', version: '^4.0.0' },
+      ]));
+
+      expect(
+        result.violations.some(
+          (v) =>
+            v.workspace === '@test/used' &&
+            v.code === 'wrong-section' &&
+            v.dependency === 'express' &&
+            v.expectedSection === 'dependencies',
+        ),
+      ).toBe(true);
+      expect(
+        result.violations.some(
+          (v) =>
+            v.workspace === '@test/unused' &&
+            v.code === 'stale' &&
+            v.dependency === 'express',
+        ),
+      ).toBe(true);
+    });
+  });
+
+  // 6. local-workspace-deps
+  describe('local-workspace-deps', () => {
+    it('places local workspace dep in dependencies with workspace:*', () => {
+      const root = makeRoot();
+      const lib = makeWorkspace('@test/shared', 'packages/shared', 'library');
+      const svc = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        undefined,
+        new Map([['@test/shared', runtimeUsage(['src/main.ts'])]]),
+      );
+      const facts = emptyFacts([root, lib, svc]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/svc')!;
+      expect(exp.sections.dependencies.get('@test/shared')).toBe('workspace:*');
+    });
+  });
+
+  // 7. peer-propagation-local-library
+  describe('peer-propagation-local-library', () => {
+    it('propagates peerDependencies from local library to consuming service', () => {
+      const root = makeRoot();
+      // foo is a library with peerDep on react
+      const foo = makeWorkspace(
+        '@test/foo',
+        'packages/foo',
+        'library',
+        { name: '@test/foo', role: 'library' },
+        new Map([['react', runtimeUsage(['src/index.ts'])]]),
+      );
+      // bar is a service that depends on foo at runtime
+      const bar = makeWorkspace(
+        '@test/bar',
+        'packages/bar',
+        'service',
+        { name: '@test/bar', role: 'service', dependencies: { '@test/foo': 'workspace:*' } },
+        new Map([['@test/foo', runtimeUsage(['src/index.ts'])]]),
+      );
+
+      const facts: DependencyModelFacts = {
+        workspaces: [root, foo, bar],
+        externalPeerMetadata: new Map(),
+        rules: [{ match: 'react', version: '>=18' }],
+      };
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/bar')!;
+      // service gets react propagated into dependencies
+      expect(exp.sections.dependencies.get('react')).toBeDefined();
+    });
+  });
+
+  // 8. rootonly-violation
+  describe('rootonly-violation', () => {
+    it('reports root-only violation when workspace declares a rootOnly dep', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        { name: '@test/svc', role: 'service', dependencies: { 'some-tool': '^1.0.0' } },
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'some-tool', rootOnly: true },
+      ]);
+      const result = deriveDependencyModel(facts);
+      expect(result.violations.some((v) => v.code === 'root-only' && v.dependency === 'some-tool')).toBe(true);
+    });
+
+    it('reports root-only-usage when workspace source imports a rootOnly dep', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        { name: '@test/svc', role: 'service' },
+        new Map([['some-tool', runtimeUsage(['src/main.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'some-tool', rootOnly: true },
+      ]);
+      const result = deriveDependencyModel(facts);
+
+      expect(
+        result.violations.some(
+          (v) =>
+            v.code === 'root-only-usage' &&
+            v.dependency === 'some-tool' &&
+            v.workspace === '@test/svc',
+        ),
+      ).toBe(true);
+    });
+
+    it('keeps required rootOnly dependencies in root devDependencies without root-only-usage', () => {
+      const root = makeRoot({
+        name: '@test/root',
+        private: true,
+        devDependencies: { 'test-harness': '^1.0.0' },
+      });
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        { name: '@test/svc', role: 'service' },
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws], [
+        {
+          match: 'test-harness',
+          workspace: '@test/svc',
+          version: '^1.0.0',
+          required: true,
+          rootOnly: true,
+        },
+      ]));
+      const rootExp = result.expected.get('.')!;
+      const wsExp = result.expected.get('packages/svc')!;
+
+      expect(rootExp.sections.devDependencies.get('test-harness')).toBe('^1.0.0');
+      expect(wsExp.sections.dependencies.has('test-harness')).toBe(false);
+      expect(
+        result.violations.some(
+          (v) =>
+            v.code === 'root-only-usage' &&
+            v.dependency === 'test-harness',
+        ),
+      ).toBe(false);
+    });
+  });
+
+  // 9. library-dev-mirror-exact
+  describe('library-dev-mirror-exact', () => {
+    it('derives devDependencies as exact mirror of peerDependencies', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([
+          ['react', runtimeUsage(['src/index.ts'])],
+          ['vue',   runtimeUsage(['src/index.ts'])],
+        ]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'react', version: '^18.0.0' },
+        { match: 'vue',   version: '^3.0.0'  },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+      expect([...exp.sections.devDependencies.entries()]).toEqual(
+        [...exp.sections.peerDependencies.entries()],
+      );
+    });
+
+    it('reports mirror violation when devDependencies range differs from peerDependencies', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        {
+          name: '@test/lib',
+          role: 'library',
+          peerDependencies: { react: '^18.0.0' },
+          devDependencies:  { react: '^17.0.0' },
+        },
+        new Map([['react', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'react', version: '^18.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      expect(
+        result.violations.some((v) => v.code === 'mirror' && v.dependency === 'react'),
+      ).toBe(true);
+    });
+
+    it('removes extra devDependencies not present in peerDependencies', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        {
+          name: '@test/lib',
+          role: 'library',
+          peerDependencies: { react: '^18.0.0' },
+          devDependencies:  { react: '^18.0.0', 'extra-dev': '^1.0.0' },
+        },
+        new Map([['react', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'react', version: '^18.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+      expect(exp.sections.devDependencies.has('extra-dev')).toBe(false);
+      expect(exp.sections.devDependencies.get('react')).toBe('^18.0.0');
+    });
+  });
+
+  // 10. library-private-type-root-dev
+  describe('library-private-type-root-dev', () => {
+    it('sends type-only imports not in dts to root devDependencies', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([['some-types', typeOnlyUsage(['src/index.ts'])]]),
+        new Set(), // NOT in dts
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'some-types', version: '^1.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const rootExp = result.expected.get('.')!;
+      const wsExp   = result.expected.get('packages/lib')!;
+      expect(rootExp.sections.devDependencies.get('some-types')).toBe('^1.0.0');
+      expect(wsExp.sections.peerDependencies.has('some-types')).toBe(false);
+      expect(wsExp.sections.devDependencies.has('some-types')).toBe(false);
+    });
+  });
+
+  // 11. library-dts-type-leak
+  describe('library-dts-type-leak', () => {
+    it('promotes type-only dep appearing in dts to public contract (peer + mirror)', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([['some-types', typeOnlyUsage(['src/index.ts'])]]),
+        new Set(['some-types']), // present in dts → public surface
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'some-types', version: '^1.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const wsExp = result.expected.get('packages/lib')!;
+      expect(wsExp.sections.peerDependencies.get('some-types')).toBe('^1.0.0');
+      expect(wsExp.sections.devDependencies.get('some-types')).toBe('^1.0.0'); // mirror
+      const rootExp = result.expected.get('.')!;
+      expect(rootExp.sections.devDependencies.has('some-types')).toBe(false);
+    });
+  });
+
+  // 12. cli-runtime-deps
+  describe('cli-runtime-deps', () => {
+    it('places runtime dep in dependencies for cli', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/cli',
+        'packages/cli',
+        'cli',
+        undefined,
+        new Map([['commander', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'commander', version: '^12.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/cli')!;
+      expect(exp.sections.dependencies.get('commander')).toBe('^12.0.0');
+      expect(exp.sections.peerDependencies.size).toBe(0);
+      expect(exp.sections.devDependencies.size).toBe(0);
+    });
+
+    it('reports forbidden-section when cli declares peerDependencies', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/cli',
+        'packages/cli',
+        'cli',
+        { name: '@test/cli', role: 'cli', peerDependencies: { commander: '^12.0.0' } },
+      );
+      const facts = emptyFacts([root, ws]);
+      const result = deriveDependencyModel(facts);
+      expect(
+        result.violations.some(
+          (v) => v.code === 'forbidden-section' && v.workspace === '@test/cli',
+        ),
+      ).toBe(true);
+    });
+  });
+
+  // 13. peer-propagation-external-package
+  describe('peer-propagation-external-package', () => {
+    it('propagates required peers of an external package to consuming service', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        undefined,
+        new Map([['some-framework', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts: DependencyModelFacts = {
+        workspaces: [root, ws],
+        externalPeerMetadata: new Map([
+          ['some-framework', new Map([['react', '^18.0.0']])],
+        ]),
+        rules: [
+          { match: 'some-framework', version: '^1.0.0'  },
+          { match: 'react',          version: '^18.0.0' },
+        ],
+      };
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/svc')!;
+      expect(exp.sections.dependencies.get('react')).toBe('^18.0.0');
+    });
+
+    it('propagates required external peers as peer + mirror for library consumers', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([['some-framework', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts: DependencyModelFacts = {
+        workspaces: [root, ws],
+        externalPeerMetadata: new Map([
+          ['some-framework', new Map([['react', '^18.0.0']])],
+        ]),
+        rules: [
+          { match: 'some-framework', section: 'dependencies', version: '^1.0.0' },
+          { match: 'react',          version: '^18.0.0' },
+        ],
+      };
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+      expect(exp.sections.peerDependencies.get('react')).toBe('^18.0.0');
+      expect(exp.sections.devDependencies.get('react')).toBe('^18.0.0'); // mirror
+    });
+  });
+
+  // 14. optional-peers-ignored
+  describe('optional-peers-ignored', () => {
+    it('does not propagate optional peers (null entry in externalPeerMetadata)', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        undefined,
+        new Map([['some-pkg', runtimeUsage(['src/index.ts'])]]),
+      );
+      // null = коллектор отфильтровал все optional peers; required peers отсутствуют
+      const facts: DependencyModelFacts = {
+        workspaces: [root, ws],
+        externalPeerMetadata: new Map([['some-pkg', null]]),
+        rules: [{ match: 'some-pkg', version: '^3.0.0' }],
+      };
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/svc')!;
+      expect(exp.sections.dependencies.get('some-pkg')).toBe('^3.0.0');
+      expect(exp.sections.dependencies.size).toBe(1); // никакие peers не добавились
+    });
+  });
+
+  // 15. repeated-dep-needs-version-rule
+  describe('repeated-dep-needs-version-rule', () => {
+    it('emits unconstrained-version violation when dep appears in multiple workspaces without a global version rule', () => {
+      const root = makeRoot();
+      const ws1 = makeWorkspace(
+        '@test/a', 'packages/a', 'service',
+        { name: '@test/a', role: 'service' },
+        new Map([['lodash', runtimeUsage(['src/a.ts'])]]),
+      );
+      const ws2 = makeWorkspace(
+        '@test/b', 'packages/b', 'service',
+        { name: '@test/b', role: 'service' },
+        new Map([['lodash', runtimeUsage(['src/b.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws1, ws2]); // нет правил → нет версионного правила для lodash
+      const result = deriveDependencyModel(facts);
+      expect(
+        result.violations.some(
+          (v) => v.code === 'unconstrained-version' && v.dependency === 'lodash',
+        ),
+      ).toBe(true);
+    });
+
+    it('does not warn when a global version rule covers the dep', () => {
+      const root = makeRoot();
+      const ws1 = makeWorkspace(
+        '@test/a', 'packages/a', 'service',
+        { name: '@test/a', role: 'service', dependencies: { lodash: '^4.17.21' } },
+      );
+      const ws2 = makeWorkspace(
+        '@test/b', 'packages/b', 'service',
+        { name: '@test/b', role: 'service', dependencies: { lodash: '^4.17.21' } },
+      );
+      const facts = emptyFacts([root, ws1, ws2], [
+        { match: 'lodash', version: '^4.17.21' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      expect(
+        result.violations.some(
+          (v) => v.code === 'unconstrained-version' && v.dependency === 'lodash',
+        ),
+      ).toBe(false);
+    });
+  });
+
+  // 16. rule-precedence-last-wins
+  describe('rule-precedence-last-wins', () => {
+    it('later version rule overrides earlier one for the same dep', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([['react', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'react', version: '^17.0.0' },
+        { match: 'react', version: '^18.0.0' }, // последнее правило побеждает
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+      expect(exp.sections.peerDependencies.get('react')).toBe('^18.0.0');
+    });
+
+    it('workspace-scoped rule overrides global section rule', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        undefined,
+        new Map([['some-pkg', runtimeUsage(['src/index.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: 'some-pkg', version: '^1.0.0' },
+        // workspace-overrides переводит dep из peerDeps в deps для конкретной библиотеки
+        { match: 'some-pkg', workspace: '@test/lib', section: 'dependencies', version: '^1.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+      expect(exp.sections.dependencies.has('some-pkg')).toBe(true);
+      expect(exp.sections.peerDependencies.has('some-pkg')).toBe(false);
+    });
+  });
+
+  // 17. wildcard-version-rule (V2)
+  describe('wildcard-version-rule', () => {
+    it('wildcard pattern counts as a version rule and suppresses unconstrained-version violation', () => {
+      const root = makeRoot();
+      const ws1 = makeWorkspace(
+        '@test/a', 'packages/a', 'service',
+        { name: '@test/a', role: 'service' },
+        new Map([['@nestjs/core', runtimeUsage(['src/a.ts'])]]),
+      );
+      const ws2 = makeWorkspace(
+        '@test/b', 'packages/b', 'service',
+        { name: '@test/b', role: 'service' },
+        new Map([['@nestjs/core', runtimeUsage(['src/b.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws1, ws2], [
+        { match: '@nestjs/*', version: '^10.0.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      expect(
+        result.violations.some((v) => v.code === 'unconstrained-version'),
+      ).toBe(false);
+    });
+
+    it('wildcard version rule applies the version to matching deps', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc', 'packages/svc', 'service',
+        undefined,
+        new Map([['@nestjs/core', runtimeUsage(['src/main.ts'])]]),
+      );
+      const facts = emptyFacts([root, ws], [
+        { match: '@nestjs/*', version: '^10.3.0' },
+      ]);
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/svc')!;
+      expect(exp.sections.dependencies.get('@nestjs/core')).toBe('^10.3.0');
+    });
+  });
+
+  describe('peer-propagation-strictness', () => {
+    it('does not propagate optional peers from a local library', () => {
+      const root = makeRoot();
+      const provider = makeWorkspace(
+        '@test/provider',
+        'packages/provider',
+        'library',
+        {
+          name: '@test/provider',
+          role: 'library',
+          peerDependenciesMeta: { react: { optional: true } },
+        },
+        new Map([['react', runtimeUsage(['src/index.ts'])]]),
+      );
+      const consumer = makeWorkspace(
+        '@test/consumer',
+        'packages/consumer',
+        'service',
+        { name: '@test/consumer', role: 'service' },
+        new Map([['@test/provider', runtimeUsage(['src/main.ts'])]]),
+      );
+      const result = deriveDependencyModel(emptyFacts([root, provider, consumer], [
+        { match: 'react', version: '^18.0.0' },
+      ]));
+      const exp = result.expected.get('packages/consumer')!;
+
+      expect(exp.sections.dependencies.has('react')).toBe(false);
+    });
+
+    it('propagates transitive external peer metadata when complete facts are provided', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        undefined,
+        new Map([['framework-a', runtimeUsage(['src/main.ts'])]]),
+      );
+      const facts: DependencyModelFacts = {
+        workspaces: [root, ws],
+        externalPeerMetadata: new Map([
+          ['framework-a', new Map([['framework-b', '^2.0.0']])],
+          ['framework-b', new Map([['framework-c', '^3.0.0']])],
+          ['framework-c', null],
+        ]),
+        rules: [
+          { match: 'framework-a', version: '^1.0.0' },
+          { match: 'framework-b', version: '^2.0.0' },
+          { match: 'framework-c', version: '^3.0.0' },
+        ],
+      };
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/svc')!;
+
+      expect(exp.sections.dependencies.get('framework-b')).toBe('^2.0.0');
+      expect(exp.sections.dependencies.get('framework-c')).toBe('^3.0.0');
+    });
+  });
+
+  describe('dts-mode', () => {
+    it('does not report missing dist when withDts is disabled', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        { name: '@test/lib', role: 'library' },
+        new Map(),
+        new Set(),
+        true,
+        false,
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws]));
+
+      expect(result.violations.some((v) => v.code === 'dist-missing')).toBe(false);
+      expect(result.warnings.length).toBe(0);
+    });
+
+    it('uses available dts facts even when withDts is disabled', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        { name: '@test/lib', role: 'library' },
+        new Map(),
+        new Set(['some-types']),
+        true,
+        true,
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws], [
+        { match: 'some-types', version: '^1.0.0' },
+      ]));
+      const exp = result.expected.get('packages/lib')!;
+
+      expect(exp.sections.peerDependencies.get('some-types')).toBe('^1.0.0');
+      expect(exp.sections.devDependencies.get('some-types')).toBe('^1.0.0');
+      expect(result.violations.some((v) => v.code === 'dist-missing')).toBe(false);
+    });
+
+    it('reports missing dist when withDts is enabled', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        { name: '@test/lib', role: 'library' },
+        new Map(),
+        new Set(),
+        true,
+        false,
+      );
+      const facts = emptyFacts([root, ws]);
+      facts.withDts = true;
+      const result = deriveDependencyModel(facts);
+
+      expect(result.violations.some((v) => v.code === 'dist-missing')).toBe(true);
+    });
+
+    it('promotes matching DefinitelyTyped provider for public dts imports', () => {
+      const root = makeRoot({
+        name: '@test/root',
+        private: true,
+        devDependencies: { '@types/lodash': '^4.17.13' },
+      });
+      const ws = makeWorkspace(
+        '@test/lib',
+        'packages/lib',
+        'library',
+        {
+          name: '@test/lib',
+          role: 'library',
+          peerDependencies: {
+            lodash: '^4.17.21',
+            '@types/lodash': '^4.17.13',
+          },
+          devDependencies: {
+            lodash: '^4.17.21',
+            '@types/lodash': '^4.17.13',
+          },
+        },
+        new Map(),
+        new Set(['lodash']),
+      );
+      const facts: DependencyModelFacts = {
+        workspaces: [root, ws],
+        externalPeerMetadata: new Map(),
+        externalTypeMetadata: new Map([
+          ['lodash', { hasBundledTypes: false }],
+        ]),
+        typeProviderPackages: new Set(['@types/lodash']),
+        rules: [
+          { match: 'lodash', version: '^4.17.21' },
+          { match: '@types/*', rootOnly: true },
+          { match: '@types/lodash', version: '^4.17.13' },
+        ],
+        withDts: true,
+      };
+      const result = deriveDependencyModel(facts);
+      const exp = result.expected.get('packages/lib')!;
+
+      expect(exp.sections.peerDependencies.get('@types/lodash')).toBe('^4.17.13');
+      expect(exp.sections.devDependencies.get('@types/lodash')).toBe('^4.17.13');
+      expect(
+        result.violations.some(
+          (v) =>
+            v.code === 'root-only-usage' &&
+            v.dependency === '@types/lodash',
+        ),
+      ).toBe(false);
+    });
+  });
+
+  describe('source-usage-safety', () => {
+    it('warns when source files were scanned but no external usage was found', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        { name: '@test/svc', role: 'service' },
+        new Map(),
+        new Set(),
+        false,
+        false,
+        2,
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws]));
+
+      expect(
+        result.warnings.some(
+          (warning) =>
+            warning.code === 'zero-external-dependencies' &&
+            warning.workspace === '@test/svc',
+        ),
+      ).toBe(true);
+    });
+
+    it('treats imports from external test roots as private dev dependencies', () => {
+      const root = makeRoot();
+      const ws = makeWorkspace(
+        '@test/svc',
+        'packages/svc',
+        'service',
+        { name: '@test/svc', role: 'service' },
+        new Map([['test-harness', runtimeUsage(['test/main.spec.ts'])]]),
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws], [
+        { match: 'test-harness', version: '^1.0.0' },
+      ]));
+      const rootExp = result.expected.get('.')!;
+      const wsExp = result.expected.get('packages/svc')!;
+
+      expect(rootExp.sections.devDependencies.get('test-harness')).toBe('^1.0.0');
+      expect(wsExp.sections.dependencies.has('test-harness')).toBe(false);
+    });
+
+    it('lists repeated dependency occurrences and explains workspace-scoped version rules', () => {
+      const root = makeRoot();
+      const ws1 = makeWorkspace(
+        '@test/a', 'packages/a', 'service',
+        { name: '@test/a', role: 'service' },
+        new Map([['lodash', runtimeUsage(['src/a.ts'])]]),
+      );
+      const ws2 = makeWorkspace(
+        '@test/b', 'packages/b', 'service',
+        { name: '@test/b', role: 'service' },
+        new Map([['lodash', runtimeUsage(['src/b.ts'])]]),
+      );
+      const result = deriveDependencyModel(emptyFacts([root, ws1, ws2], [
+        { match: 'lodash', workspace: '@test/a', version: '^4.17.21' },
+      ]));
+      const violation = result.violations.find(
+        (v) => v.code === 'unconstrained-version' && v.dependency === 'lodash',
+      );
+
+      expect(violation?.message).toContain('occurrences: packages/a:dependencies, packages/b:dependencies');
+      expect(violation?.message).toContain('workspace-scoped version rules do not satisfy V1');
+    });
+  });
+});