@pikku/inspector 0.12.59 → 0.12.61

package/src/utils/filter-inspector-state.ts

@@ -3,10 +3,23 @@ import type {
   InspectorFilters,
   InspectorLogger,
 } from '../types.js'
-import type { PikkuWiringTypes } from '@pikku/core'
-import { parseVersionedId } from '@pikku/core'
+import type { PikkuWiringTypes } from '@pikku/core/types'
+import { parseVersionedId } from '@pikku/core/utils'
+import { makeContextBasedId } from './extract-function-name.js'
 import { aggregateRequiredServices } from './post-process.js'
-import { resolveDeployTarget } from './resolve-deploy-target.js'
+import {
+  IncompatibleDeployTargetError,
+  resolveDeployTarget,
+} from './resolve-deploy-target.js'
+
+/**
+ * The deploy filter, asked about one function at a time rather than handed over
+ * as a set, so that a function's own deploy conflict is raised only if this app
+ * turns out to wire it.
+ */
+type DeployFilter = {
+  has(pikkuFuncId: string): boolean
+}
 
 // Module-level Set to track warned groups across multiple filter calls
 const globalWarnedGroups = new Set<string>()
@@ -97,6 +110,13 @@ function matchesFilters(
   meta: {
     type: PikkuWiringTypes
     name: string
+    /**
+     * Further ids the `--names` filter may address this wiring by. An HTTP
+     * route wired with `ref('ns:fn')` carries the addon's own function id as
+     * its name, so its `http:<method>:<route>` wiring id is the only id that
+     * names this route rather than every wiring onto that addon function.
+     */
+    altNames?: string[]
     tags?: string[]
     filePath?: string
     httpRoute?: string
@@ -105,9 +125,10 @@ function matchesFilters(
   },
   logger: InspectorLogger,
   warnedGroups?: Set<string>,
-  // Set of pikkuFuncIds to keep based on the deploy filter; null when
-  // the deploy filter is inactive.
-  keptByDeploy?: Set<string> | null
+  // Kept pikkuFuncIds under the deploy filter; null when the filter is
+  // inactive. Asked about one id at a time, which is what lets a conflict in an
+  // addon's own metadata surface only for a function this app actually wires.
+  keptByDeploy?: DeployFilter | null
 ): boolean {
   // If no filters, allow everything
   if (Object.keys(filters).length === 0) return true
@@ -188,10 +209,15 @@ function matchesFilters(
     }
   }
 
-  const { baseName } = parseVersionedId(meta.name)
+  const candidateNames = [meta.name, ...(meta.altNames ?? [])]
   const matchesNamePattern = (pattern: string) =>
-    matchesWildcard(meta.name, pattern) ||
-    (baseName !== meta.name && matchesWildcard(baseName, pattern))
+    candidateNames.some((candidate) => {
+      const { baseName } = parseVersionedId(candidate)
+      return (
+        matchesWildcard(candidate, pattern) ||
+        (baseName !== candidate && matchesWildcard(baseName, pattern))
+      )
+    })
 
   // Check name include filter (match against both full ID and base name for versioned functions)
   if (filters.names && filters.names.length > 0) {
@@ -330,7 +356,7 @@ export function filterInspectorState(
   // Precompute kept-function set for the deploy filter (if active).
   // resolveDeployTarget throws IncompatibleDeployTargetError when an
   // explicit deploy: 'serverless' clashes with serverlessIncompatible.
-  let keptByDeploy: Set<string> | null = null
+  let keptByDeploy: DeployFilter | null = null
   if (
     (filters.target && filters.target.length > 0) ||
     (filters.excludeTarget && filters.excludeTarget.length > 0)
@@ -341,17 +367,56 @@ export function filterInspectorState(
       : null
     const incompatible = new Set(filters.serverlessIncompatible ?? [])
     const defaultTarget = filters.defaultTarget ?? 'serverless'
-    keptByDeploy = new Set<string>()
-    for (const [funcId, funcMeta] of Object.entries(state.functions.meta)) {
+    const kept = new Set<string>()
+    // An addon publishes metadata for everything it exports, so a conflict in a
+    // function this app never wires is not this app's build error. Holding it
+    // here and raising it from `has` reports it at the one place the app is
+    // known to depend on that function.
+    const conflicts = new Map<string, IncompatibleDeployTargetError>()
+    keptByDeploy = {
+      has: (funcId: string) => {
+        const conflict = conflicts.get(funcId)
+        if (conflict) throw conflict
+        return kept.has(funcId)
+      },
+    }
+    const keepByTarget = (
+      funcId: string,
+      funcMeta: unknown,
+      incompatibleServices: Set<string>
+    ) => {
       const target = resolveDeployTarget(
         funcMeta as any,
-        incompatible,
+        incompatibleServices,
         funcId,
         defaultTarget
       )
-      if (allowed && !allowed.has(target)) continue
-      if (excluded && excluded.has(target)) continue
-      keptByDeploy.add(funcId)
+      if (allowed && !allowed.has(target)) return
+      if (excluded && excluded.has(target)) return
+      kept.add(funcId)
+    }
+    for (const [funcId, funcMeta] of Object.entries(state.functions.meta)) {
+      keepByTarget(funcId, funcMeta, incompatible)
+    }
+    // A wiring onto an addon function records the addon's own id, so the
+    // addon's published metadata is the only place its deploy target can be
+    // read from. Its serverlessIncompatible services are namespace-scoped —
+    // a service name means whatever the addon that declared it means.
+    for (const [namespace, addonMeta] of Object.entries(
+      state.addonFunctions ?? {}
+    )) {
+      const addonIncompatible = new Set(
+        state.addonServerlessIncompatible?.get(namespace) ?? []
+      )
+      for (const [funcName, funcMeta] of Object.entries(addonMeta)) {
+        const funcId = `${namespace}:${funcName}`
+        try {
+          keepByTarget(funcId, funcMeta, addonIncompatible)
+        } catch (e) {
+          if (!(e instanceof IncompatibleDeployTargetError)) throw e
+          conflicts.set(funcId, e)
+        }
+      }
     }
   }
 
@@ -459,6 +524,7 @@ export function filterInspectorState(
         {
           type: 'http' as PikkuWiringTypes,
           name: routeMeta.pikkuFuncId, // Use function name, not route
+          altNames: [makeContextBasedId('http', method, routeMeta.route)],
           tags: routeMeta.tags,
           filePath,
           httpRoute: routeMeta.route,
@@ -478,11 +544,6 @@ export function filterInspectorState(
           filteredState.serviceAggregation.usedFunctions.add(
             routeMeta.pikkuFuncId
           )
-          if (routeMeta.refTarget) {
-            filteredState.serviceAggregation.usedFunctions.add(
-              routeMeta.refTarget
-            )
-          }
           // For workflow/agent routes, also add the base name
           // so the workflow/agent definition survives pruning
           const colonIdx = routeMeta.pikkuFuncId.indexOf(':')

package/src/utils/filter-utils.ts

@@ -1,5 +1,5 @@
 import type { InspectorFilters, InspectorLogger } from '../types.js'
-import type { PikkuWiringTypes } from '@pikku/core'
+import type { PikkuWiringTypes } from '@pikku/core/types'
 
 /**
  * Match a value against a pattern with wildcard support

package/src/utils/get-property-value.ts

@@ -127,6 +127,46 @@ export const assertStringLiteralProperty = (
   }
 }
 
+/**
+ * Fold a node that is a compile-time constant string down to its value.
+ *
+ * The fallback below this is `getText()`, which returns the node's *source*.
+ * For a lone `'…'` that is indistinguishable from the value, so nobody noticed
+ * that anything written as an expression comes through raw: a `description`
+ * split across lines as `'Fetch the thing ' + 'from upstream'` reaches
+ * `infra.json` with the quotes and the `+` still in it, and is rendered that
+ * way in the fabric console.
+ *
+ * Deliberately checker-free, unlike `extractStringLiteral`. Every value this
+ * resolves is a literal in the same expression, so no symbol resolution is
+ * needed, and `getPropertyValue` is called from a dozen places that have no
+ * checker to hand. Anything it cannot fold — an identifier, a template with a
+ * substitution — returns `undefined` and takes the old path, so this only ever
+ * turns a wrong answer into a right one.
+ */
+const foldStaticString = (node: ts.Node): string | undefined => {
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text
+  }
+  if (ts.isParenthesizedExpression(node)) {
+    return foldStaticString(node.expression)
+  }
+  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+    return foldStaticString(node.expression)
+  }
+  if (
+    ts.isBinaryExpression(node) &&
+    node.operatorToken.kind === ts.SyntaxKind.PlusToken
+  ) {
+    const left = foldStaticString(node.left)
+    if (left === undefined) return undefined
+    const right = foldStaticString(node.right)
+    if (right === undefined) return undefined
+    return left + right
+  }
+  return undefined
+}
+
 export const getPropertyValue = (
   obj: ts.ObjectLiteralExpression,
   propertyName: string
@@ -174,11 +214,9 @@ export const getPropertyValue = (
       return Number(initializer.text)
     }
 
-    if (
-      ts.isStringLiteral(initializer) ||
-      ts.isNoSubstitutionTemplateLiteral(initializer)
-    ) {
-      return initializer.text
+    const staticString = foldStaticString(initializer)
+    if (staticString !== undefined) {
+      return staticString
     }
 
     return initializer.getText()

package/src/utils/load-addon-functions-meta.ts

@@ -1,3 +1,4 @@
+import { existsSync } from 'fs'
 import { readFile, readdir } from 'fs/promises'
 import { createRequire } from 'module'
 import { join, dirname } from 'path'
@@ -141,6 +142,44 @@ const resolveAddonMeta = (
   return null
 }
 
+/**
+ * Give the addon's input/output type names a declaration file to be imported
+ * from, so a wiring that references an addon function can name its contract.
+ *
+ * Without this the only thing that knows where `GetScenarioArtifactInput` lives
+ * is the type checker, and it only knows once the consumer's *own* rpc map has
+ * already been generated with the addon's routes in it — which is to say on the
+ * second run. A first, cold run resolved `ref('console:getScenarioArtifact')`
+ * against a map that did not mention it yet and fell back to the whole
+ * `FlattenedRPCMap`, so the same source produced a different http-map depending
+ * on whether `.pikku` happened to be there. The addon publishes these types at a
+ * fixed subpath; reading them from the metadata makes the first run agree with
+ * the second.
+ */
+const registerAddonTypes = (
+  state: InspectorState,
+  metaPath: string,
+  meta: Record<string, any>
+): void => {
+  // Derived from the metadata's own location rather than resolved as a package
+  // subpath: the addon exports that declaration under a `types`-only condition,
+  // which `require.resolve` will not follow.
+  const typesPath = join(
+    dirname(metaPath),
+    '..',
+    'rpc',
+    'pikku-rpc-wirings-map.internal.gen.d.ts'
+  )
+  if (!existsSync(typesPath)) return
+
+  for (const funcMeta of Object.values(meta)) {
+    for (const name of [funcMeta.inputSchemaName, funcMeta.outputSchemaName]) {
+      if (!name || state.functions.typesMap.exists(name, typesPath)) continue
+      state.functions.typesMap.addType(name, typesPath)
+    }
+  }
+}
+
 /**
  * After the setup sweep discovers wireAddon() declarations, load each addon
  * package's function metadata so that wiring handlers (channels, HTTP routes,
@@ -177,6 +216,7 @@ export async function loadAddonFunctionsMeta(
       logger.debug(
         `Loaded ${Object.keys(meta).length} addon functions for '${namespace}' from ${decl.package}`
       )
+      registerAddonTypes(state, metaPath, meta)
 
       // If wireAddon has mcp: true, expose addon functions with mcp: true as MCP tools
       if (decl.mcp) {

package/src/utils/middleware.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'node:test'
 import assert from 'node:assert'
-import { resolveAIMiddleware } from './middleware.js'
+import { resolveAgentMiddleware } from './middleware.js'
 import { getInitialInspectorState } from '../inspector.js'
 import * as ts from 'typescript'
 
@@ -26,39 +26,39 @@ function createMockChecker(): ts.TypeChecker {
   return {} as any
 }
 
-describe('resolveAIMiddleware', () => {
-  test('should return undefined when no aiMiddleware property exists', () => {
+describe('resolveAgentMiddleware', () => {
+  test('should return undefined when no agentMiddleware property exists', () => {
     const state = getInitialInspectorState('/test')
     const src = createSourceFile('const x = { name: "test" }')
     const obj = getObjectLiteral(src)
     const checker = createMockChecker()
 
-    const result = resolveAIMiddleware(state, obj, checker)
+    const result = resolveAgentMiddleware(state, obj, checker)
 
     assert.strictEqual(result, undefined)
   })
 
-  test('should return undefined when aiMiddleware array is empty', () => {
+  test('should return undefined when agentMiddleware array is empty', () => {
     const state = getInitialInspectorState('/test')
-    const src = createSourceFile('const x = { aiMiddleware: [] }')
+    const src = createSourceFile('const x = { agentMiddleware: [] }')
     const obj = getObjectLiteral(src)
     const checker = createMockChecker()
 
-    const result = resolveAIMiddleware(state, obj, checker)
+    const result = resolveAgentMiddleware(state, obj, checker)
 
     assert.strictEqual(result, undefined)
   })
 
-  test('should resolve aiMiddleware identifiers as wire metadata', () => {
+  test('should resolve agentMiddleware identifiers as wire metadata', () => {
     const state = getInitialInspectorState('/test')
-    state.aiMiddleware.definitions['myAIMW'] = {
+    state.agentMiddleware.definitions['myAIMW'] = {
       services: { optimized: true, services: ['logger'] },
       sourceFile: '/test/middleware.ts',
       position: 0,
       exportedName: 'myAIMW',
     }
 
-    const code = 'const x = { aiMiddleware: [myAIMW] }'
+    const code = 'const x = { agentMiddleware: [myAIMW] }'
     const program = ts.createProgram({
       rootNames: ['test.ts'],
       options: { target: ts.ScriptTarget.ESNext },
@@ -77,7 +77,7 @@ describe('resolveAIMiddleware', () => {
     const sourceFile = program.getSourceFile('test.ts')!
     const obj = getObjectLiteral(sourceFile)
 
-    const result = resolveAIMiddleware(state, obj, checker)
+    const result = resolveAgentMiddleware(state, obj, checker)
 
     assert.ok(result)
     assert.strictEqual(result.length, 1)
@@ -88,22 +88,22 @@ describe('resolveAIMiddleware', () => {
     })
   })
 
-  test('should resolve multiple aiMiddleware entries', () => {
+  test('should resolve multiple agentMiddleware entries', () => {
     const state = getInitialInspectorState('/test')
-    state.aiMiddleware.definitions['firstMW'] = {
+    state.agentMiddleware.definitions['firstMW'] = {
       services: { optimized: true, services: ['logger'] },
       sourceFile: '/test/middleware.ts',
       position: 0,
       exportedName: 'firstMW',
     }
-    state.aiMiddleware.definitions['secondMW'] = {
+    state.agentMiddleware.definitions['secondMW'] = {
       services: { optimized: true, services: [] },
       sourceFile: '/test/middleware.ts',
       position: 100,
       exportedName: 'secondMW',
     }
 
-    const code = 'const x = { aiMiddleware: [firstMW, secondMW] }'
+    const code = 'const x = { agentMiddleware: [firstMW, secondMW] }'
     const program = ts.createProgram({
       rootNames: ['test.ts'],
       options: { target: ts.ScriptTarget.ESNext },
@@ -122,7 +122,7 @@ describe('resolveAIMiddleware', () => {
     const sourceFile = program.getSourceFile('test.ts')!
     const obj = getObjectLiteral(sourceFile)
 
-    const result = resolveAIMiddleware(state, obj, checker)
+    const result = resolveAgentMiddleware(state, obj, checker)
 
     assert.ok(result)
     assert.strictEqual(result.length, 2)
@@ -132,16 +132,16 @@ describe('resolveAIMiddleware', () => {
     assert.strictEqual((result[1] as any).name, 'secondMW')
   })
 
-  test('should mark inline aiMiddleware (null exportedName)', () => {
+  test('should mark inline agentMiddleware (null exportedName)', () => {
     const state = getInitialInspectorState('/test')
-    state.aiMiddleware.definitions['inlineMW'] = {
+    state.agentMiddleware.definitions['inlineMW'] = {
       services: { optimized: true, services: [] },
       sourceFile: '/test/middleware.ts',
       position: 0,
       exportedName: null,
     }
 
-    const code = 'const x = { aiMiddleware: [inlineMW] }'
+    const code = 'const x = { agentMiddleware: [inlineMW] }'
     const program = ts.createProgram({
       rootNames: ['test.ts'],
       options: { target: ts.ScriptTarget.ESNext },
@@ -160,7 +160,7 @@ describe('resolveAIMiddleware', () => {
     const sourceFile = program.getSourceFile('test.ts')!
     const obj = getObjectLiteral(sourceFile)
 
-    const result = resolveAIMiddleware(state, obj, checker)
+    const result = resolveAgentMiddleware(state, obj, checker)
 
     assert.ok(result)
     assert.strictEqual(result.length, 1)
@@ -171,10 +171,10 @@ describe('resolveAIMiddleware', () => {
     })
   })
 
-  test('should handle aiMiddleware referencing unknown definitions', () => {
+  test('should handle agentMiddleware referencing unknown definitions', () => {
     const state = getInitialInspectorState('/test')
 
-    const code = 'const x = { aiMiddleware: [unknownMW] }'
+    const code = 'const x = { agentMiddleware: [unknownMW] }'
     const program = ts.createProgram({
       rootNames: ['test.ts'],
       options: { target: ts.ScriptTarget.ESNext },
@@ -193,7 +193,7 @@ describe('resolveAIMiddleware', () => {
     const sourceFile = program.getSourceFile('test.ts')!
     const obj = getObjectLiteral(sourceFile)
 
-    const result = resolveAIMiddleware(state, obj, checker)
+    const result = resolveAgentMiddleware(state, obj, checker)
 
     assert.ok(result)
     assert.strictEqual(result.length, 1)

package/src/utils/middleware.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import type { MiddlewareMetadata } from '@pikku/core'
+import type { MiddlewareMetadata } from '@pikku/core/middleware'
 import { extractFunctionName } from './extract-function-name.js'
 import type { InspectorState } from '../types.js'
 
@@ -214,24 +214,24 @@ export function resolveHTTPMiddlewareFromObject(
   )
 }
 
-function getAIMiddlewareNode(
+function getAgentMiddlewareNode(
   obj: ts.ObjectLiteralExpression
 ): ts.Expression | undefined {
   const prop = obj.properties.find(
     (p) =>
       ts.isPropertyAssignment(p) &&
       ts.isIdentifier(p.name) &&
-      p.name.text === 'aiMiddleware'
+      p.name.text === 'agentMiddleware'
   ) as ts.PropertyAssignment | undefined
   return prop?.initializer
 }
 
-export function resolveAIMiddleware(
+export function resolveAgentMiddleware(
   state: InspectorState,
   obj: ts.ObjectLiteralExpression,
   checker: ts.TypeChecker
 ): MiddlewareMetadata[] | undefined {
-  const explicitNode = getAIMiddlewareNode(obj)
+  const explicitNode = getAgentMiddlewareNode(obj)
   if (!explicitNode) return undefined
 
   const names = extractMiddlewarePikkuNames(
@@ -240,7 +240,7 @@ export function resolveAIMiddleware(
     state.rootDir
   )
   const resolved: MiddlewareMetadata[] = names.map((name) => {
-    const def = state.aiMiddleware.definitions[name]
+    const def = state.agentMiddleware.definitions[name]
     return {
       type: 'wire' as const,
       name,

package/src/utils/permissions.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import type { PermissionMetadata } from '@pikku/core'
+import type { PermissionMetadata } from '@pikku/core/function'
 import { extractFunctionName } from './extract-function-name.js'
 import type { InspectorState } from '../types.js'
 

package/src/utils/post-process.test.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert'
 import { describe, test } from 'node:test'
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs'
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import {
@@ -142,7 +142,7 @@ function makeState(
 
 const CONSOLE_PARENT_SERVICES = [
   'metaService',
-  'aiAgentRunner',
+  'agentRunner',
   'deploymentService',
   'credentialService',
 ]
@@ -187,7 +187,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
           runAgent: {
             services: {
               optimized: true,
-              services: ['aiAgentRunner', 'deploymentService'],
+              services: ['agentRunner', 'deploymentService'],
             },
           },
         },
@@ -197,7 +197,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
     aggregateRequiredServices(state)
     const required = state.serviceAggregation.requiredServices
     assert.ok(required.has('metaService'))
-    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('agentRunner'))
     assert.ok(!required.has('deploymentService'))
     assert.ok(!required.has('credentialService'))
   })
@@ -258,7 +258,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
     const required = state.serviceAggregation.requiredServices
     assert.ok(required.has('kysely'))
     assert.ok(!required.has('metaService'))
-    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('agentRunner'))
   })
 
   test('no used addon functions adds no parent services', () => {
@@ -279,7 +279,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
     aggregateRequiredServices(state)
     const required = state.serviceAggregation.requiredServices
     assert.ok(!required.has('metaService'))
-    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('agentRunner'))
   })
 
   test('internal services in addon function meta never force the blanket', () => {
@@ -300,7 +300,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
     aggregateRequiredServices(state)
     const required = state.serviceAggregation.requiredServices
     assert.ok(required.has('metaService'))
-    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('agentRunner'))
     assert.ok(!required.has('rpc'))
   })
 
@@ -345,7 +345,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
     aggregateRequiredServices(state)
     const required = state.serviceAggregation.requiredServices
     assert.ok(required.has('metaService'))
-    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('agentRunner'))
   })
 
   test('multiple used addon functions union their parent services', () => {
@@ -357,7 +357,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
             services: { optimized: true, services: ['metaService'] },
           },
           runAgent: {
-            services: { optimized: true, services: ['aiAgentRunner'] },
+            services: { optimized: true, services: ['agentRunner'] },
           },
         },
       },
@@ -366,7 +366,7 @@ describe('aggregateRequiredServices — per-function addon services', () => {
     aggregateRequiredServices(state)
     const required = state.serviceAggregation.requiredServices
     assert.ok(required.has('metaService'))
-    assert.ok(required.has('aiAgentRunner'))
+    assert.ok(required.has('agentRunner'))
     assert.ok(!required.has('deploymentService'))
     assert.ok(!required.has('credentialService'))
   })
@@ -579,10 +579,67 @@ describe('validateRemoteAddonDependencies (wireRemoteAddon must be a devDependen
     }
   })
 
-  test('ignores a non-remote (wireAddon) declaration', () => {
+  test('a non-remote (wireAddon) declaration is judged on resolvability, not package.json', () => {
+    // Being listed as a dependency is not what makes an addon usable — it is
+    // discovered because it is wired, and it can arrive by workspace link or a
+    // local addons/ directory without ever appearing here. So a declared but
+    // absent package is still an error.
     const { logger, criticals } = makeCriticalLogger()
     const dir = writePkg({ '@addon/local': '1.0.0' }, {})
     try {
+      validateRemoteAddonDependencies(
+        logger,
+        makeRemoteState(dir, { package: '@addon/local' })
+      )
+      assert.equal(criticals.length, 1)
+      assert.equal(criticals[0]!.code, ErrorCode.ADDON_NOT_INSTALLED)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('a non-remote addon present only in node_modules passes', () => {
+    // The inverse, and the case that matters: installed by link, absent from
+    // package.json. Reported as missing, this would fail every project whose
+    // addon lives in a local addons/ directory.
+    const { logger, criticals } = makeCriticalLogger()
+    const dir = writePkg({}, {})
+    try {
+      const pkgDir = join(dir, 'node_modules', '@addon', 'local')
+      mkdirSync(pkgDir, { recursive: true })
+      writeFileSync(
+        join(pkgDir, 'package.json'),
+        JSON.stringify({ name: '@addon/local', version: '1.0.0' })
+      )
+      validateRemoteAddonDependencies(
+        logger,
+        makeRemoteState(dir, { package: '@addon/local' })
+      )
+      assert.deepEqual(criticals, [])
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('an exports map that refuses package.json is not read as missing', () => {
+    // `require.resolve('<pkg>/package.json')` throws ERR_PACKAGE_PATH_NOT_EXPORTED
+    // on a package with a restrictive exports map. Reaching the exports map
+    // means the package was found, so that must not count as absent.
+    const { logger, criticals } = makeCriticalLogger()
+    const dir = writePkg({}, {})
+    try {
+      const pkgDir = join(dir, 'node_modules', '@addon', 'local')
+      mkdirSync(pkgDir, { recursive: true })
+      writeFileSync(
+        join(pkgDir, 'package.json'),
+        JSON.stringify({
+          name: '@addon/local',
+          version: '1.0.0',
+          main: 'index.js',
+          exports: { '.': './index.js' },
+        })
+      )
+      writeFileSync(join(pkgDir, 'index.js'), 'module.exports = {}\n')
       validateRemoteAddonDependencies(
         logger,
         makeRemoteState(dir, { package: '@addon/local' })