@astryxdesign/cli 0.6.3-canary.f22695a → 0.6.3

package/foundation/integrations/integrations.mjs

@@ -6,19 +6,13 @@
  * Integrations are PACKAGE NAMES listed in astryx.config.{ts,mjs,js}. Each
  * package declares a single conventional root manifest sibling to its
  * package.json — astryx.integration.{ts,mjs,js} — which contributes
- * components/templates/codemods/docs/themes roots and an optional issuesUrl.
- * Stable provider identity and package metadata come from package.json, not the
- * manifest.
- *
- * @input Integration package names, package.json files, and root manifests.
- * @output LoadedIntegration records with normalized provider identity and roots.
- * @position foundation/integrations — package contribution loading boundary.
+ * components/templates/codemods/docs/themes roots and an optional issuesUrl. Identity
+ * (name, version) comes from the package's package.json, not the manifest.
  */
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import {assertWithin} from '../fs/path-safety.mjs';
-import {normalizeProviderId} from '../identity/provider-identity.mjs';
 // The key census and contribution parsers are internal to the schema module on
 // purpose: the public parser still validates the complete authored type, while
 // the loader can isolate an invalid optional contribution from valid roots.
@@ -37,10 +31,6 @@ import {parseGapReportHandler} from '../../authoring/gap-report/parse.mjs';
  * are internal bookkeeping used by Doctor integration validation and Project.
  * @typedef {object} LoadedIntegration
  * @property {string} name
- * @property {import('../../authoring/identity/type').ProviderId} [providerId]
- *   normalized stable provider identity; absent only for a legacy unnamed local
- *   package. Unique among contributing integrations: a later claimant is kept
- *   inert with `__providerConflict` (see {@link markProviderConflicts})
  * @property {string} [version]
  * @property {string} [components]
  * @property {string} [templates]
@@ -59,10 +49,6 @@ import {parseGapReportHandler} from '../../authoring/gap-report/parse.mjs';
  * @property {string} __manifestFile
  * @property {string} [__loadError] set when the manifest failed to load/validate;
  *   such an integration contributes nothing and is surfaced via Project.issues()
- * @property {{providerId: import('../../authoring/identity/type').ProviderId, claimedBy: string, message: string}} [__providerConflict]
- *   set on a package whose provider ID an earlier-loaded package already
- *   claims; it contributes nothing and is reported as a `duplicate_provider`
- *   warning
  * @property {string[]} [__unknownKeys] manifest keys this CLI does not know —
  *   surfaced as a warning; the rest of the manifest still contributes
  * @property {boolean} [__autolinked] loaded because the project declares the
@@ -88,137 +74,6 @@ export const MANIFEST_BASENAMES = [
   'astryx.integration.js',
 ];
 
-/**
- * Normalize a package-owned provider ID without rejecting legacy unnamed local
- * packages at this compatibility boundary.
- * @param {unknown} name
- * @returns {import('../../authoring/identity/type').ProviderId | undefined}
- */
-function providerIdForPackage(name) {
-  if (typeof name !== 'string' || name.length === 0) return undefined;
-  try {
-    return normalizeProviderId(name);
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Resolve provider identity across loaded integrations, in precedence order.
- *
- * Artifact and document IDs are provider-scoped, so two packages cannot both
- * contribute under one provider ID. The same package reached twice (an npm
- * alias beside the package it aliases, with the same name and version) loads
- * once. Any other later claimant, including the same package at another
- * version, stays as an inert entry that carries the conflict. The package being
- * authored claims its ID before precedence order is considered, because the
- * source being edited is authoritative. The winner still contributes; Project
- * issues, Doctor, and the per-command warning name the one set aside instead of
- * dropping it without a word.
- *
- * @param {LoadedIntegration[]} integrations in precedence order
- * @returns {LoadedIntegration[]}
- */
-export function markProviderConflicts(integrations) {
-  /** @type {Map<string, LoadedIntegration>} */
-  const claims = new Map();
-  for (const integration of integrations) {
-    if (integration?.__local && claimsProvider(integration)) {
-      const providerId = /** @type {string} */ (integration.providerId);
-      if (!claims.has(providerId)) claims.set(providerId, integration);
-    }
-  }
-  /** @type {LoadedIntegration[]} */
-  const resolved = [];
-  for (const integration of integrations) {
-    if (!claimsProvider(integration)) {
-      resolved.push(integration);
-      continue;
-    }
-    const providerId = /** @type {string} */ (integration.providerId);
-    const claimant = claims.get(providerId);
-    if (claimant == null) {
-      claims.set(providerId, integration);
-      resolved.push(integration);
-    } else if (claimant === integration) {
-      resolved.push(integration);
-    } else if (
-      claimant.name !== integration.name ||
-      claimant.version !== integration.version
-    ) {
-      resolved.push(providerConflict(integration, claimant));
-    }
-  }
-  return resolved;
-}
-
-/**
- * Whether an entry contributes under its provider ID: it has one, its manifest
- * loaded, and it has not already been set aside.
- * @param {LoadedIntegration | undefined} integration
- * @returns {boolean}
- */
-function claimsProvider(integration) {
-  return (
-    integration?.providerId != null &&
-    integration.__loadError == null &&
-    integration.__providerConflict == null
-  );
-}
-
-/**
- * @param {LoadedIntegration} integration
- * @returns {string}
- */
-function describeIntegration(integration) {
-  const id = integration.version
-    ? `${integration.name}@${integration.version}`
-    : integration.name;
-  return integration.__spec && integration.__spec !== integration.name
-    ? `${id} (from "${integration.__spec}")`
-    : id;
-}
-
-/**
- * An inert record for a package whose provider ID is already claimed. It keeps
- * the package's identity and location for reporting, and drops every
- * contribution root and handler.
- * @param {LoadedIntegration} integration
- * @param {LoadedIntegration} claimant
- * @returns {LoadedIntegration}
- */
-function providerConflict(integration, claimant) {
-  const providerId =
-    /** @type {import('../../authoring/identity/type').ProviderId} */ (
-      integration.providerId
-    );
-  const winner = describeIntegration(claimant);
-  const setAside = describeIntegration(integration);
-  const reason = claimant.__local
-    ? 'is the package being authored, so it is used'
-    : 'loads first and is used';
-  return {
-    name: integration.name,
-    providerId,
-    version: integration.version,
-    __spec: integration.__spec,
-    __packageDir: integration.__packageDir,
-    __manifestFile: integration.__manifestFile,
-    ...(integration.__local ? {__local: true} : {}),
-    ...(integration.__autolinked
-      ? {__autolinked: true, __dependencyField: integration.__dependencyField}
-      : {}),
-    __providerConflict: {
-      providerId,
-      claimedBy: claimant.name,
-      message:
-        `${setAside} and ${winner} both claim provider ID "${providerId}". ` +
-        `${winner} ${reason}; ${setAside} contributes nothing ` +
-        'until one package changes its providerId.',
-    },
-  };
-}
-
 /**
  * Return the conventional root manifest paths present in `dir`, in
  * load-precedence order. Unlike {@link resolveManifestPath} this never throws —
@@ -419,7 +274,6 @@ export async function loadLocalIntegration(packageDir, {fresh = false} = {}) {
     typeof pkg.name === 'string' && pkg.name.length > 0
       ? pkg.name
       : '(local integration)';
-  const packageProviderId = providerIdForPackage(pkg.name);
   const manifestFile = resolveManifestPath(packageDir, spec);
 
   let manifest;
@@ -445,7 +299,6 @@ export async function loadLocalIntegration(packageDir, {fresh = false} = {}) {
   } catch (err) {
     return {
       name: spec,
-      ...(packageProviderId == null ? {} : {providerId: packageProviderId}),
       version: pkg.version,
       __spec: spec,
       __packageDir: packageDir,
@@ -455,8 +308,6 @@ export async function loadLocalIntegration(packageDir, {fresh = false} = {}) {
     };
   }
 
-  const providerId = providerIdForPackage(manifest.providerId ?? pkg.name);
-
   /** @param {string | null | undefined} value */
   const resolveRoot = value => {
     if (value == null) return undefined;
@@ -469,7 +320,6 @@ export async function loadLocalIntegration(packageDir, {fresh = false} = {}) {
 
   return {
     name: spec,
-    ...(providerId == null ? {} : {providerId}),
     version: pkg.version,
     components: resolveRoot(manifest.components),
     templates: resolveRoot(manifest.templates),
@@ -495,22 +345,20 @@ export async function loadLocalIntegration(packageDir, {fresh = false} = {}) {
  * Load configured integrations.
  *
  * @param {string[]} [specs] package names
- * @param {{cwd?: string, fresh?: boolean, resolveProviders?: boolean}} [options]
- *   `resolveProviders: false` leaves provider identity to a caller that
- *   resolves it once over a larger set (Project.load)
+ * @param {{cwd?: string, fresh?: boolean}} [options]
  * @returns {Promise<LoadedIntegration[]>}
  */
 export async function loadIntegrations(
   specs = [],
-  {cwd = process.cwd(), fresh = false, resolveProviders = true} = {},
+  {cwd = process.cwd(), fresh = false} = {},
 ) {
   /** @type {LoadedIntegration[]} */
   const integrations = [];
-  const seenSpecs = new Set();
+  const seen = new Set();
 
   for (const spec of specs) {
-    if (!spec || seenSpecs.has(spec)) continue;
-    seenSpecs.add(spec);
+    if (!spec || seen.has(spec)) continue;
+    seen.add(spec);
 
     const packageDir = resolvePackageDir(spec, cwd);
     const pkgPath = path.join(packageDir, 'package.json');
@@ -523,7 +371,6 @@ export async function loadIntegrations(
       );
     }
 
-    const packageProviderId = providerIdForPackage(pkg.name ?? spec);
     const manifestFile = resolveManifestPath(packageDir, spec);
     let manifest;
     /** @type {string[]} */
@@ -552,7 +399,6 @@ export async function loadIntegrations(
       // discovery loops naturally skip it (no components/templates/codemods).
       integrations.push({
         name: pkg.name ?? spec,
-        ...(packageProviderId == null ? {} : {providerId: packageProviderId}),
         version: pkg.version,
         __spec: spec,
         __packageDir: packageDir,
@@ -562,10 +408,6 @@ export async function loadIntegrations(
       continue;
     }
 
-    const providerId = providerIdForPackage(
-      manifest.providerId ?? pkg.name ?? spec,
-    );
-
     /** @param {string | null | undefined} value */
     const resolveRoot = value => {
       if (value == null) return undefined;
@@ -579,7 +421,6 @@ export async function loadIntegrations(
 
     integrations.push({
       name: pkg.name ?? spec,
-      ...(providerId == null ? {} : {providerId}),
       version: pkg.version,
       components: resolveRoot(manifest.components),
       templates: resolveRoot(manifest.templates),
@@ -600,5 +441,5 @@ export async function loadIntegrations(
     });
   }
 
-  return resolveProviders ? markProviderConflicts(integrations) : integrations;
+  return integrations;
 }

package/foundation/integrations/integrations.test.mjs

@@ -77,7 +77,6 @@ describe('configured integrations', () => {
     const loaded = project.loadedIntegrations[0];
     // Identity comes from package.json, not the manifest.
     expect(loaded.name).toBe('@acme/widgets');
-    expect(loaded.providerId).toBe('@acme/widgets');
     expect(loaded.version).toBe('1.2.3');
     expect(loaded.components).toBe(path.join(pkgDir, 'docs'));
     expect(loaded.templates).toBe(path.join(pkgDir, 'blocks'));
@@ -85,43 +84,6 @@ describe('configured integrations', () => {
     expect(loaded.issuesUrl).toBe('https://example.com/issues');
   });
 
-  it('preserves provider identity across an explicit package rename', async () => {
-    writeManifestPackage(tmpDir, {
-      body: `export default {providerId: '@acme/legacy-widgets'};\n`,
-    });
-
-    const [loaded] = await loadIntegrations(['@acme/widgets'], {cwd: tmpDir});
-    expect(loaded.name).toBe('@acme/widgets');
-    expect(loaded.providerId).toBe('@acme/legacy-widgets');
-    expect(loaded.__unknownKeys).toEqual([]);
-  });
-
-  it('deduplicates package aliases by canonical provider identity', async () => {
-    writeManifestPackage(tmpDir, {body: `export default {};\n`});
-    const aliasDir = path.join(
-      tmpDir,
-      'node_modules',
-      '@acme',
-      'widgets-alias',
-    );
-    fs.mkdirSync(aliasDir, {recursive: true});
-    fs.writeFileSync(
-      path.join(aliasDir, 'package.json'),
-      JSON.stringify({name: '@acme/widgets', version: '1.2.3'}),
-    );
-    fs.writeFileSync(
-      path.join(aliasDir, 'astryx.integration.mjs'),
-      `export default {};\n`,
-    );
-
-    const loaded = await loadIntegrations(
-      ['@acme/widgets', '@acme/widgets-alias'],
-      {cwd: tmpDir},
-    );
-    expect(loaded).toHaveLength(1);
-    expect(loaded[0].providerId).toBe('@acme/widgets');
-  });
-
   it('makes integration components discoverable', async () => {
     const pkgDir = writeManifestPackage(tmpDir, {
       body: `export default { components: './docs' };\n`,
@@ -245,347 +207,6 @@ describe('configured integrations', () => {
   });
 });
 
-describe('provider identity conflicts', () => {
-  /**
-   * Install one integration package that contributes a single component.
-   * @param {string} dir directory under node_modules
-   * @param {{name: string, version: string}} pkg package.json identity
-   * @param {Record<string, unknown>} manifest extra manifest fields
-   * @param {string} component the component it contributes
-   */
-  function installPackage(dir, pkg, manifest, component) {
-    const pkgDir = path.join(tmpDir, 'node_modules', ...dir.split('/'));
-    const componentsDir = path.join(pkgDir, 'components');
-    fs.mkdirSync(componentsDir, {recursive: true});
-    fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify(pkg));
-    fs.writeFileSync(
-      path.join(pkgDir, 'astryx.integration.mjs'),
-      `export default ${JSON.stringify({components: './components', ...manifest})};\n`,
-    );
-    fs.writeFileSync(
-      path.join(componentsDir, `${component}.doc.mjs`),
-      `export default {type: 'component', name: '${component}', props: []};\n`,
-    );
-    fs.writeFileSync(
-      path.join(componentsDir, `${component}.tsx`),
-      `export function ${component}() { return null; }\n`,
-    );
-  }
-
-  /** @param {string[]} integrations */
-  function configure(integrations) {
-    fs.writeFileSync(
-      path.join(tmpDir, 'astryx.config.mjs'),
-      `export default ${JSON.stringify({integrations})};\n`,
-    );
-  }
-
-  /**
-   * Make the project directory itself the package being authored.
-   * @param {Record<string, unknown>} pkg package.json fields
-   * @param {Record<string, unknown>} manifest extra manifest fields
-   * @param {string} component the component it contributes
-   */
-  function writeLocalPackage(pkg, manifest, component) {
-    const componentsDir = path.join(tmpDir, 'local-components');
-    fs.mkdirSync(componentsDir, {recursive: true});
-    fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify(pkg));
-    fs.writeFileSync(
-      path.join(tmpDir, 'astryx.integration.mjs'),
-      `export default ${JSON.stringify({components: './local-components', ...manifest})};\n`,
-    );
-    fs.writeFileSync(
-      path.join(componentsDir, `${component}.doc.mjs`),
-      `export default {type: 'component', name: '${component}', props: []};\n`,
-    );
-    fs.writeFileSync(
-      path.join(componentsDir, `${component}.tsx`),
-      `export function ${component}() { return null; }\n`,
-    );
-  }
-
-  /** @param {import('../config/project.mjs').Project} project */
-  async function conflictIssues(project) {
-    return (await project.issues()).filter(
-      issue => issue.code === 'duplicate_provider',
-    );
-  }
-
-  it('keeps the first package and reports a different package claiming its ID', async () => {
-    installPackage(
-      '@acme/widgets',
-      {name: '@acme/widgets', version: '1.0.0'},
-      {},
-      'Widget',
-    );
-    installPackage(
-      '@acme/renamed',
-      {name: '@acme/renamed', version: '2.0.0'},
-      {providerId: '@acme/widgets'},
-      'RenamedWidget',
-    );
-    configure(['@acme/widgets', '@acme/renamed']);
-
-    const loaded = await loadIntegrations(['@acme/widgets', '@acme/renamed'], {
-      cwd: tmpDir,
-    });
-    expect(loaded.map(integration => integration.name)).toEqual([
-      '@acme/widgets',
-      '@acme/renamed',
-    ]);
-    expect(loaded[1]).toMatchObject({
-      providerId: '@acme/widgets',
-      __providerConflict: {
-        providerId: '@acme/widgets',
-        claimedBy: '@acme/widgets',
-      },
-    });
-    expect(loaded[1].components).toBeUndefined();
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    const owned = (await project.components()).map(component => [
-      component.package,
-      component.name,
-    ]);
-    expect(owned).toContainEqual(['@acme/widgets', 'Widget']);
-    expect(owned.some(([pkg]) => pkg === '@acme/renamed')).toBe(false);
-    expect(await project.issues()).toContainEqual(
-      expect.objectContaining({
-        package: '@acme/renamed@2.0.0',
-        code: 'duplicate_provider',
-        severity: 'warning',
-        message: expect.stringContaining(
-          '@acme/widgets@1.0.0 loads first and is used',
-        ),
-      }),
-    );
-  });
-
-  it('reports the same package configured again at another version', async () => {
-    installPackage(
-      '@acme/widgets',
-      {name: '@acme/widgets', version: '1.0.0'},
-      {},
-      'Widget',
-    );
-    installPackage(
-      'widgets-next',
-      {name: '@acme/widgets', version: '2.0.0'},
-      {},
-      'NextWidget',
-    );
-    configure(['@acme/widgets', 'widgets-next']);
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    const owned = (await project.components()).map(component => component.name);
-    expect(owned).toContain('Widget');
-    expect(owned).not.toContain('NextWidget');
-    expect(await project.issues()).toContainEqual(
-      expect.objectContaining({
-        package: '@acme/widgets@2.0.0',
-        code: 'duplicate_provider',
-        severity: 'warning',
-        message: expect.stringContaining('(from "widgets-next")'),
-      }),
-    );
-  });
-
-  it('reports an autolinked dependency that claims a configured ID', async () => {
-    installPackage(
-      '@acme/widgets',
-      {name: '@acme/widgets', version: '1.0.0'},
-      {},
-      'Widget',
-    );
-    installPackage(
-      '@acme/renamed',
-      {name: '@acme/renamed', version: '2.0.0'},
-      {providerId: '@acme/widgets'},
-      'RenamedWidget',
-    );
-    configure(['@acme/widgets']);
-    fs.writeFileSync(
-      path.join(tmpDir, 'package.json'),
-      JSON.stringify({
-        name: 'consumer',
-        dependencies: {'@acme/renamed': '2.0.0'},
-      }),
-    );
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    expect(
-      project.loadedIntegrations.find(
-        integration => integration.name === '@acme/renamed',
-      ),
-    ).toMatchObject({
-      __autolinked: true,
-      __providerConflict: {claimedBy: '@acme/widgets'},
-    });
-    expect(await project.issues()).toContainEqual(
-      expect.objectContaining({
-        package: '@acme/renamed@2.0.0',
-        code: 'duplicate_provider',
-      }),
-    );
-  });
-
-  it("reports a set-aside package whose spec is the winner's name", async () => {
-    installPackage(
-      'widgets-old',
-      {name: '@acme/widgets', version: '1.0.0'},
-      {},
-      'OldWidget',
-    );
-    installPackage(
-      '@acme/widgets',
-      {name: '@acme/widgets', version: '2.0.0'},
-      {},
-      'NewWidget',
-    );
-    configure(['widgets-old', '@acme/widgets']);
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    const owned = (await project.components()).map(component => component.name);
-    expect(owned).toContain('OldWidget');
-    expect(owned).not.toContain('NewWidget');
-    expect(await conflictIssues(project)).toEqual([
-      expect.objectContaining({
-        package: '@acme/widgets@2.0.0',
-        severity: 'warning',
-        message: expect.stringContaining(
-          '@acme/widgets@2.0.0 and @acme/widgets@1.0.0 (from "widgets-old") both claim',
-        ),
-      }),
-    ]);
-  });
-
-  it('reports an unversioned set-aside package whose spec is the winner\'s name', async () => {
-    installPackage(
-      'widgets-old',
-      {name: '@acme/widgets', version: '1.0.0'},
-      {},
-      'OldWidget',
-    );
-    installPackage('@acme/widgets', {name: '@acme/widgets'}, {}, 'NewWidget');
-    configure(['widgets-old', '@acme/widgets']);
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    expect(await conflictIssues(project)).toEqual([
-      expect.objectContaining({
-        package: '@acme/widgets',
-        message: expect.stringContaining(
-          '@acme/widgets@1.0.0 (from "widgets-old") loads first and is used',
-        ),
-      }),
-    ]);
-  });
-
-  it('reports an autolinked alias of the same package at another version', async () => {
-    installPackage(
-      '@acme/legacy-ui',
-      {name: '@acme/ui', version: '0.1.22'},
-      {},
-      'LegacyButton',
-    );
-    installPackage(
-      '@acme/ui',
-      {name: '@acme/ui', version: '1.0.0'},
-      {},
-      'NewButton',
-    );
-    fs.rmSync(path.join(tmpDir, 'astryx.config.mjs'));
-    fs.writeFileSync(
-      path.join(tmpDir, 'package.json'),
-      JSON.stringify({
-        name: 'consumer',
-        dependencies: {
-          '@acme/legacy-ui': 'npm:@acme/ui@0.1.22',
-          '@acme/ui': '1.0.0',
-        },
-      }),
-    );
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    const owned = (await project.components()).map(component => component.name);
-    expect(owned).toContain('LegacyButton');
-    expect(owned).not.toContain('NewButton');
-    expect(await conflictIssues(project)).toEqual([
-      expect.objectContaining({
-        package: '@acme/ui@1.0.0',
-        message: expect.stringContaining(
-          '@acme/ui@1.0.0 and @acme/ui@0.1.22 (from "@acme/legacy-ui") both claim',
-        ),
-      }),
-    ]);
-  });
-
-  it('recomputes conflicts after the authored package replaces its installed copy', async () => {
-    installPackage(
-      '@acme/widgets',
-      {name: '@acme/widgets', version: '1.0.0'},
-      {},
-      'Widget',
-    );
-    installPackage(
-      '@acme/renamed',
-      {name: '@acme/renamed', version: '2.0.0'},
-      {providerId: '@acme/widgets'},
-      'RenamedWidget',
-    );
-    configure(['@acme/widgets', '@acme/renamed']);
-    writeLocalPackage(
-      {name: '@acme/widgets', version: '3.0.0-dev'},
-      {providerId: '@acme/widgets-next'},
-      'LocalWidget',
-    );
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    expect(
-      project.loadedIntegrations.some(
-        integration => integration.__providerConflict,
-      ),
-    ).toBe(false);
-    const owned = (await project.components()).map(component => component.name);
-    expect(owned).toEqual(
-      expect.arrayContaining(['LocalWidget', 'RenamedWidget']),
-    );
-    expect(owned).not.toContain('Widget');
-    expect(await conflictIssues(project)).toEqual([]);
-  });
-
-  it('lets the package being authored win over its installed predecessor', async () => {
-    installPackage(
-      '@acme/widgets',
-      {name: '@acme/widgets', version: '1.0.0'},
-      {},
-      'Widget',
-    );
-    fs.rmSync(path.join(tmpDir, 'astryx.config.mjs'));
-    writeLocalPackage(
-      {
-        name: '@acme/renamed',
-        version: '2.0.0-dev',
-        devDependencies: {'@acme/widgets': '1.0.0'},
-      },
-      {providerId: '@acme/widgets'},
-      'RenamedWidget',
-    );
-
-    const project = await Project.load(tmpDir, {fresh: true});
-    const owned = (await project.components()).map(component => component.name);
-    expect(owned).toContain('RenamedWidget');
-    expect(owned).not.toContain('Widget');
-    expect(await conflictIssues(project)).toEqual([
-      expect.objectContaining({
-        package: '@acme/widgets@1.0.0',
-        message: expect.stringContaining(
-          '@acme/renamed@2.0.0-dev is the package being authored, so it is used',
-        ),
-      }),
-    ]);
-  });
-});
-
 describe('local integration self-resolution', () => {
   it('preserves a valid gapReport named export', async () => {
     fs.writeFileSync(
@@ -604,11 +225,7 @@ export default {};
 
     const loaded = await loadLocalIntegration(tmpDir, {fresh: true});
 
-    expect(loaded).toMatchObject({
-      name: '@acme/local',
-      providerId: '@acme/local',
-      __local: true,
-    });
+    expect(loaded).toMatchObject({name: '@acme/local', __local: true});
     expect(loaded?.__gapReport?.audience).toBe('internal');
     expect(
       loaded?.__gapReport?.handle(

package/foundation/integrations/validate-contributions.d.mts

@@ -22,7 +22,5 @@ export function validateLoadedIntegration(loaded: LoadedIntegration): Promise<Is
  */
 /** Stable issue code for an invalid optional agent-doc contribution. */
 export const INVALID_AGENT_DOCS: "invalid_agent_docs";
-/** Stable issue code for a package whose provider ID is already claimed. */
-export const DUPLICATE_PROVIDER: "duplicate_provider";
 export type Issue = import("./issue").AstryxIntegrationIssue;
 export type LoadedIntegration = import("./integrations.mjs").LoadedIntegration;