pinokiod 8.0.45 → 8.0.46

package/server/lib/app_log_report.js

@@ -2,10 +2,12 @@ const fs = require('fs')
 const os = require('os')
 const path = require('path')
 const Environment = require('../../kernel/environment')
+const { createCurrentSystemSnapshot } = require('./log_redaction')
 
 const DEFAULT_TAIL_LINES = 800
 const MAX_SECTION_CHARS = 120000
 const SENSITIVE_ENV_KEY = /(?:TOKEN|SECRET|PASSWORD|PASSWD|PASSPHRASE|API[_-]?KEY|APIKEY|CREDENTIAL|COOKIE|SESSION|AUTH|PRIVATE[_-]?KEY)/i
+const SENSITIVE_FIELD_KEY = /(?:^|[_-])(?:TOKEN|SECRET|PASSWORD|PASSWD|PASSPHRASE|API[_-]?KEY|APIKEY|CREDENTIAL|COOKIE|SESSION|AUTH|AUTHORIZATION|PRIVATE[_-]?KEY)(?:$|[_-])/i
 
 const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
@@ -52,6 +54,13 @@ class AppLogReportService {
       }
     }
 
+    let systemSpec = this.buildSystemSpec()
+    if (redact) {
+      const redacted = this.redactStructuredValue(systemSpec, { appRoot, workspaceRoot })
+      systemSpec = redacted.value
+      this.mergeCounts(totals, redacted.counts)
+    }
+
     const metadata = {
       app_id: appId,
       title: status.title || appId,
@@ -62,7 +71,7 @@ class AppLogReportService {
       arch: os.arch(),
       node: process.version,
       tail_count: tailLines,
-      system_spec: this.buildSystemSpec(),
+      system_spec: systemSpec,
       redaction_mode: redact ? 'server_deterministic' : 'none',
       latest_session: sessionIndex.latest_session,
       session: selectedSession,
@@ -305,6 +314,27 @@ class AppLogReportService {
     }
   }
 
+  redactStructuredValue(input, context = {}) {
+    const counts = {}
+    const json = JSON.stringify(input, (key, value) => {
+      const normalizedKey = String(key).replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+      if (key && SENSITIVE_FIELD_KEY.test(normalizedKey) && value !== undefined && value !== null && value !== '') {
+        counts.env_secrets = (counts.env_secrets || 0) + 1
+        return '[REDACTED_SECRET]'
+      }
+      if (typeof value === 'string') {
+        const redacted = this.redactText(value, context)
+        this.mergeCounts(counts, redacted.counts)
+        return redacted.text
+      }
+      return value
+    })
+    return {
+      value: JSON.parse(json),
+      counts
+    }
+  }
+
   renderMarkdown(metadata, sections, redactions) {
     const lines = [
       '# Issue Report',
@@ -418,9 +448,11 @@ class AppLogReportService {
   buildSystemSpec() {
     const kernel = this.kernel || {}
     const info = kernel.sysinfo && typeof kernel.sysinfo === 'object' ? kernel.sysinfo : {}
-    return this.compactObject({
+    const version = this.readPinokioVersion()
+    const snapshot = createCurrentSystemSnapshot(kernel, version)
+    const spec = this.compactObject({
       pinokio: {
-        version: this.readPinokioVersion(),
+        version,
         node: process.version,
         platform: kernel.platform || process.platform,
         arch: kernel.arch || process.arch
@@ -438,6 +470,16 @@ class AppLogReportService {
       gpus: this.sanitizeGpus(info.gpus),
       graphics: this.sanitizeGraphics(info.graphics)
     })
+
+    return {
+      ...spec,
+      hardware: {
+        ...spec.hardware,
+        gpu_driver: snapshot.gpu_driver ?? null,
+        gpu_target: snapshot.gpu_target ?? null
+      },
+      diagnostics: snapshot
+    }
   }
 
   sanitizeOsInfo(value) {

package/server/lib/log_redaction.js

@@ -95,6 +95,28 @@ function createFallbackStateSnapshot(kernel) {
   }
 }
 
+function createCurrentSystemSnapshot(kernel, version) {
+  kernel = kernel || {}
+  return {
+    platform: kernel.platform,
+    arch: kernel.arch,
+    running: kernel.api && kernel.api.running,
+    home: kernel.homedir,
+    vars: kernel.vars,
+    memory: kernel.memory,
+    procs: kernel.procs,
+    gpu: kernel.gpu,
+    gpus: kernel.gpus,
+    gpu_model: kernel.gpu_model,
+    gpu_driver: kernel.gpu_driver,
+    gpu_target: kernel.gpu_target,
+    ram: kernel.ram,
+    vram: kernel.vram,
+    version,
+    ...kernel.sysinfo
+  }
+}
+
 function createCurrentLogSnapshot(kernel, version) {
   const liveShells = kernel && kernel.shell && Array.isArray(kernel.shell.shells)
     ? kernel.shell.shells
@@ -118,21 +140,10 @@ function createCurrentLogSnapshot(kernel, version) {
     }
   }
 
-  const info = {
-    platform: kernel.platform,
-    arch: kernel.arch,
-    running: kernel.api.running,
-    home: kernel.homedir,
-    vars: kernel.vars,
-    memory: kernel.memory,
-    procs: kernel.procs,
-    gpu: kernel.gpu,
-    gpus: kernel.gpus,
-    version,
-    ...kernel.sysinfo
+  return {
+    info: createCurrentSystemSnapshot(kernel, version),
+    states
   }
-
-  return { info, states }
 }
 
 async function writeCurrentLogSnapshot(kernel, version) {
@@ -418,6 +429,7 @@ module.exports = {
   LOG_REDACTION_FILE_MAX_BYTES,
   isTopLevelRedactableLogPath,
   normalizeTailLineCount,
+  createCurrentSystemSnapshot,
   createCurrentLogSnapshot,
   writeCurrentLogSnapshot,
   normalizeLogRedactionOverrides,

package/server/public/nav.js

@@ -6,7 +6,7 @@ document.addEventListener("DOMContentLoaded", () => {
 
   const newWindowButton = document.querySelector("#new-window");
   const agent = document.body.getAttribute("data-agent");
-  if (newWindowButton && !headerCollapseOnly) {
+  if (newWindowButton) {
     newWindowButton.addEventListener("click", (event) => {
       if (agent === "electron") {
         window.open("/", "_blank", "pinokio");

package/server/public/style.css

@@ -4536,7 +4536,6 @@ aside .qr {
   body.main-sidebar-page > header.navheader #inspector,
   body.main-sidebar-page > header.navheader #mobile-link-button,
   body.main-sidebar-page > header.navheader .urlbar,
-  body.main-sidebar-page > header.navheader #close-window,
   body.main-sidebar-page > header.navheader .runner,
   body.main-sidebar-page > header.navheader h1 > .path,
   body.main-sidebar-page > header.navheader h1 > .nav-button,

package/server/public/vault.js

@@ -56,15 +56,13 @@ const COPY = {
   scan_queued: "Waiting to start scan",
   scan_analyzing: "Analyzing large files",
   scan_finishing: "Finishing scan",
-  scan_estimate_help: "Overall progress combines file scanning and large-file analysis",
   scan_counting_help: "The first scan cannot know its total until this pass finishes",
-  scan_count_estimate_help: "Estimated from the exact file total and timing of the last completed scan",
-  scan_file_progress_help: "This pass uses the exact current file total; overall timing is estimated from the last scan",
-  scan_hash_progress_help: "File discovery is complete; the remaining large-file count is exact",
+  scan_file_progress_help: "Based on the exact current file total",
+  scan_hash_progress_help: "Based on the exact large-file count and current-file bytes",
   scan_finishing_help: "File analysis is complete; deduplication records are being verified",
-  about_percent: "About {percent} percent.",
   exact_percent: "{percent} percent.",
   scan_checked: "{done} of {total} large files checked",
+  scan_file_bytes: "{done} of {total}",
   scan_files_checked: "{done} of {total} files checked",
   scan_folders: "folders checked",
   scan_files: "files checked",
@@ -903,50 +901,48 @@ const renderOverview = () => {
     const verifying = scanPhase === "verifying"
     const hashTotal = scan.hash_total || 0
     const hashDone = Math.min(Math.max(0, hashTotal - (scan.queued || 0)), hashTotal)
-    const hashRatio = hashTotal ? Math.min(1, hashDone / hashTotal) : 1
+    const currentFileSize = Math.max(0, Number(scan.current_file_size) || 0)
+    const currentFileBytes = Math.min(currentFileSize, Math.max(0, Number(scan.current_file_bytes) || 0))
+    const currentFileRatio = currentFileSize ? currentFileBytes / currentFileSize : 0
+    const hashRatio = hashTotal ? Math.min(1, (hashDone + currentFileRatio) / hashTotal) : 1
     const scanSource = scan.scope_id ? sourceById(scan.scope_id) : null
     const scanProgressLabel = scanSource
       ? COPY.scan_location.replace("{location}", scanSource.label)
       : COPY.scan_progress
     const phase = queued ? COPY.scan_queued : counting ? COPY.scan_counting : walking ? scanProgressLabel : verifying ? COPY.scan_finishing : COPY.scan_analyzing
-    const rawCountWeight = Number.isFinite(scan.estimated_count_weight) ? scan.estimated_count_weight : 0.4
-    const countWeight = Math.max(0, Math.min(0.98, rawCountWeight))
-    const rawWalkWeight = Number.isFinite(scan.estimated_walk_weight) ? scan.estimated_walk_weight : 0.5
-    const walkWeight = Math.max(0, Math.min(0.98 - countWeight, rawWalkWeight))
-    const analysisWeight = Math.max(0, 1 - countWeight - walkWeight)
-    const countEstimate = Number.isFinite(scan.count_estimate_files) && scan.count_estimate_files > 0
-      ? scan.count_estimate_files
-      : null
-    const countRatio = countEstimate === null ? null : Math.min(1, (scan.counted_files || 0) / countEstimate)
     const totalFiles = Number.isFinite(scan.total_files) ? scan.total_files : null
     const details = counting
       ? [`${scan.counted_dirs || 0} ${COPY.scan_folders_found}`, `${scan.counted_files || 0} ${COPY.scan_files_found}`]
       : [`${scan.dirs || 0} ${COPY.scan_folders}`, totalFiles === null
           ? `${scan.files || 0} ${COPY.scan_files}`
           : COPY.scan_files_checked.replace("{done}", scan.files || 0).replace("{total}", totalFiles), fmt(scan.bytes_total || 0)]
-    if (scan.current_file) details.push(`${COPY.analyzing} ${scan.current_file}`)
+    if (scan.current_file) {
+      const fileProgress = currentFileSize
+        ? ` (${COPY.scan_file_bytes.replace("{done}", fmt(currentFileBytes)).replace("{total}", fmt(currentFileSize))})`
+        : ""
+      details.push(`${COPY.analyzing} ${scan.current_file}${fileProgress}`)
+    }
     if (walking && scan.queued > 1) details.push(`${scan.queued} ${COPY.waiting}`)
     if (!walking && hashTotal) {
       details.push(COPY.scan_checked.replace("{done}", hashDone).replace("{total}", hashTotal))
     }
     let percent = ""
     let progress
-    if (queued || (counting && countRatio === null) || (walking && totalFiles === null)) {
-      const ariaText = `${details.join(" · ")}. ${COPY.scan_counting_help}.`
+    if (queued || counting || verifying || (walking && totalFiles === null)) {
+      const progressHelp = verifying
+        ? COPY.scan_finishing_help
+        : counting ? COPY.scan_counting_help : phase
+      const ariaText = `${details.join(" · ")}. ${progressHelp}.`
       progress = { determinate: false, ariaText }
     } else {
-      const progressRatio = counting
-        ? countRatio * countWeight
-        : verifying
-        ? 0.99
-        : walking
-        ? countWeight + ((totalFiles ? Math.min(1, (scan.files || 0) / totalFiles) : 1) * walkWeight)
-        : Math.min(0.98, countWeight + walkWeight + (analysisWeight * hashRatio))
+      const progressRatio = walking
+        ? (totalFiles ? Math.min(1, (scan.files || 0) / totalFiles) : 1)
+        : hashRatio
       const boundedProgress = Math.max(0, Math.min(1, progressRatio))
       const progressValue = Math.round(boundedProgress * 1000) / 10
-      const progressHelp = counting ? COPY.scan_count_estimate_help : verifying ? COPY.scan_finishing_help : walking ? COPY.scan_file_progress_help : COPY.scan_estimate_help
-      const progressText = COPY.about_percent.replace("{percent}", progressValue)
-      percent = `~${progressValue}%`
+      const progressHelp = walking ? COPY.scan_file_progress_help : COPY.scan_hash_progress_help
+      const progressText = COPY.exact_percent.replace("{percent}", progressValue)
+      percent = `${progressValue}%`
       progress = { determinate: true, value: progressValue, ratio: boundedProgress, help: progressHelp, text: progressText }
     }
     if (!scanState.querySelector(".vault-progress-track")) {

package/server/views/vault.ejs

@@ -23,6 +23,8 @@
   <%- include('partials/main_sidebar', { selected: 'vault' }) %>
 </main>
 <script src="/Socket.js"></script>
+<script src="/common.js"></script>
+<script src="/nav.js" data-header-collapse-only></script>
 <script src="/storage-size.js"></script>
 <script src="/vault.js"></script>
 </body>

package/test/amd-gfx-generator.test.js

@@ -0,0 +1,75 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const generator = require('../script/update-amd-gfx-targets')
+
+test('AMD generator joins LLVM aliases, Mesa families, and PCI IDs', () => {
+  const llvm = `
+    def : ProcessorModel<"gfx803", Model, FeatureISAVersion8_0_3.Features>;
+    def : ProcessorModel<"polaris10", Model, FeatureISAVersion8_0_3.Features>;
+  `
+  const families = `
+    const char *ac_get_llvm_processor_name(enum radeon_family family) {
+      switch (family) {
+      case CHIP_POLARIS10:
+        return "polaris10";
+      case CHIP_NAVI23:
+        return "gfx1032";
+      }
+    }
+    const char *ac_get_ip_type_string(void) {}
+  `
+
+  const processors = generator.parseLlvmProcessorTargets(llvm)
+  const familyTargets = generator.parseMesaFamilyTargets(families, processors)
+  const entries = generator.parseMesaPciTargets(
+    'CHIPSET(0x67DF, POLARIS10)\n',
+    familyTargets
+  )
+  generator.parseLinuxPciTargets(
+    '{0x1002, 0x73FF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_DIMGREY_CAVEFISH},',
+    familyTargets,
+    { DIMGREY_CAVEFISH: 'NAVI23' },
+    entries
+  )
+
+  assert.equal(familyTargets.POLARIS10, 'gfx803')
+  assert.equal(entries['1002:67df'].target, 'gfx803')
+  assert.equal(entries['1002:73ff'].target, 'gfx1032')
+})
+
+test('AMD generator derives former Mesa family aliases from pinned comments', () => {
+  assert.deepEqual(generator.parseMesaFamilyAliases(`
+    CHIP_NAVI21, /* formerly "Sienna Cichlid" */
+    CHIP_NAVI23, /* formerly "Dimgrey Cavefish" */
+  `), {
+    SIENNA_CICHLID: 'NAVI21',
+    DIMGREY_CAVEFISH: 'NAVI23'
+  })
+})
+
+test('AMD generator rejects conflicting PCI family targets', () => {
+  assert.throws(() => generator.parseLinuxPciTargets(
+    [
+      '{0x1002, 0x73FF, 0, 0, 0, 0, CHIP_NAVI21},',
+      '{0x1002, 0x73FF, 0, 0, 0, 0, CHIP_NAVI23},'
+    ].join('\n'),
+    { NAVI21: 'gfx1030', NAVI23: 'gfx1032' },
+    {}
+  ), /Conflicting targets/)
+})
+
+test('AMD generator keeps exact libdrm revisions without promoting model names', () => {
+  const pciTargets = {}
+  const revisions = generator.parseLibdrmRevisionTargets(
+    '744c, c8, AMD Radeon RX 7900 XTX\n',
+    { 'radeon rx 7900 xtx': 'gfx1100' },
+    pciTargets
+  )
+
+  assert.deepEqual(revisions['1002:744c:c8'], {
+    target: 'gfx1100',
+    model: 'AMD Radeon RX 7900 XTX'
+  })
+  assert.equal(pciTargets['1002:744c'], undefined)
+})

package/test/amd-gpu-target.test.js

@@ -6,17 +6,19 @@ const test = require('node:test')
 const system = require('systeminformation')
 
 const amd = require('../kernel/gpu/amd')
+const amdPci = require('../kernel/gpu/amd_pci')
 const gfxTargets = require('../kernel/gpu/amd_gfx_targets.json')
+const pciTargets = require('../kernel/gpu/amd_pci_targets.json')
 const packageJson = require('../package.json')
 const Sysinfo = require('../kernel/sysinfo')
 
 const root = path.join(__dirname, '..')
 
 test('AMD gfx generated data is checked in and self describing', () => {
-  assert.equal(
-    gfxTargets.source,
-    'https://raw.githubusercontent.com/ROCm/ROCm/develop/docs/reference/gpu-arch-specs.rst'
-  )
+  assert.match(gfxTargets.source, new RegExp(gfxTargets.source_revision))
+  assert.doesNotMatch(gfxTargets.source, /\/develop\//)
+  assert.match(gfxTargets.source_revision, /^[0-9a-f]{40}$/)
+  assert.match(gfxTargets.source_sha256, /^[0-9a-f]{64}$/)
   assert.equal(gfxTargets.generated_by, 'script/update-amd-gfx-targets.js')
 
   assert.equal(gfxTargets.entries['radeon rx 6800 xt'], 'gfx1030')
@@ -24,8 +26,32 @@ test('AMD gfx generated data is checked in and self describing', () => {
   assert.equal(gfxTargets.entries.mi210, 'gfx90a')
 })
 
+test('AMD PCI generated data is pinned, auditable, and covers mobile and RDNA1 GPUs', () => {
+  assert.equal(pciTargets.generated_by, 'script/update-amd-gfx-targets.js')
+  assert.ok(pciTargets.sources.length >= 6)
+  for (const source of pciTargets.sources) {
+    assert.match(source.revision, /^[0-9a-f]{40}$/)
+    assert.match(source.sha256, /^[0-9a-f]{64}$/)
+    assert.match(source.url, new RegExp(source.revision))
+    assert.doesNotMatch(source.url, /\/(?:main|master|develop)\//)
+  }
+
+  assert.equal(pciTargets.entries['1002:731f'].target, 'gfx1010')
+  assert.equal(pciTargets.entries['1002:7340'].target, 'gfx1012')
+  assert.equal(pciTargets.entries['1002:73ff'].target, 'gfx1032')
+  assert.equal(pciTargets.entries['1002:73ff'].family, 'NAVI23')
+  assert.equal(pciTargets.revision_entries['1002:73ff:c3'].model, 'AMD Radeon RX 6600M')
+  assert.equal(pciTargets.revision_entries['1002:73ff:c3'].target, 'gfx1032')
+  assert.equal(pciTargets.revision_entries['1002:744c:c8'].target, 'gfx1100')
+  assert.equal(
+    Object.values(pciTargets.entries).some((entry) => entry.family === 'LIBDRM_MODEL_CONSENSUS'),
+    false
+  )
+})
+
 test('AMD gfx target refresh is an explicit maintainer command', () => {
   assert.equal(packageJson.scripts['update:amd-gfx-targets'], 'node script/update-amd-gfx-targets.js')
+  assert.equal(packageJson.scripts['check:amd-gfx-targets'], 'node script/update-amd-gfx-targets.js --check')
   assert.equal(Object.prototype.hasOwnProperty.call(packageJson.scripts, 'update:amd-rocm-targets'), false)
 
   for (const script of ['preinstall', 'install', 'postinstall', 'prestart', 'start', 'poststart']) {
@@ -51,6 +77,13 @@ test('AMD gfx resolver maps common product names to exact gfx targets', () => {
   }
 })
 
+test('AMD model resolver does not hand-maintain product gaps covered by PCI identity', () => {
+  assert.equal(gfxTargets.entries['radeon rx 6600m'], undefined)
+  assert.equal(amd.resolve_rocm_gfx_target('AMD Radeon RX 6600'), 'gfx1032')
+  assert.equal(amd.resolve_rocm_gfx_target('AMD Radeon RX 6600M'), null)
+  assert.equal(amd.resolve_rocm_gfx_target('AMD Radeon(TM) RX 6600M'), null)
+})
+
 test('AMD gfx resolver rejects unknown products and preserves raw gfx targets', () => {
   const unknownModels = [
     'AMD Radeon RX 480',
@@ -88,6 +121,9 @@ test('AMD gpu_target resolution uses CPU brand only for generic Radeon Graphics
 })
 
 test('Sysinfo exposes AMD gpu_target for resolved discrete GPUs', async (t) => {
+  t.mock.method(amdPci, 'resolve_gpu_target', async () => {
+    throw new Error('PCI fallback should not run for a resolved model')
+  })
   t.mock.method(system, 'graphics', async () => ({
     controllers: [
       {
@@ -109,7 +145,63 @@ test('Sysinfo exposes AMD gpu_target for resolved discrete GPUs', async (t) => {
   assert.equal(sys.info.gpu_target, 'gfx1030')
 })
 
+test('Sysinfo exposes AMD gpu_target for a PCI-resolved mobile GPU', async (t) => {
+  t.mock.method(amdPci, 'resolve_gpu_target', async (controller) => {
+    assert.equal(controller.model, 'AMD Radeon RX 6600M')
+    return 'gfx1032'
+  })
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'Advanced Micro Devices, Inc.',
+        model: 'AMD Radeon(TM) Graphics',
+        vram: 512
+      },
+      {
+        vendor: 'Advanced Micro Devices, Inc.',
+        model: 'AMD Radeon RX 6600M',
+        vram: 8192
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'amd')
+  assert.equal(sys.info.gpu_model, 'amd radeon rx 6600m')
+  assert.equal(sys.info.gpu_target, 'gfx1032')
+})
+
+test('Sysinfo uses exact AMD PCI identity after model lookup misses', async (t) => {
+  t.mock.method(amdPci, 'resolve_gpu_target', async (controller) => {
+    assert.equal(controller.model, 'AMD Radeon RX 5700 XT')
+    return 'gfx1010'
+  })
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'AMD',
+        model: 'AMD Radeon RX 5700 XT',
+        vram: 8192
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu_target, 'gfx1010')
+})
+
 test('Sysinfo leaves unresolved AMD gpu_target null', async (t) => {
+  t.mock.method(amdPci, 'resolve_gpu_target', async () => null)
   t.mock.method(system, 'graphics', async () => ({
     controllers: [
       {
@@ -133,6 +225,9 @@ test('Sysinfo leaves unresolved AMD gpu_target null', async (t) => {
 
 test('Sysinfo exposes AMD gpu_target through generic APU CPU fallback', async (t) => {
   let cpuBrandCalls = 0
+  t.mock.method(amdPci, 'resolve_gpu_target', async () => {
+    throw new Error('PCI fallback should not run for a resolved APU')
+  })
   t.mock.method(system, 'graphics', async () => ({
     controllers: [
       {
@@ -159,11 +254,14 @@ test('Sysinfo exposes AMD gpu_target through generic APU CPU fallback', async (t
   assert.equal(cpuBrandCalls, 1)
 })
 
-test('AMD gfx runtime resolver stays offline and data-only', () => {
-  const source = fs.readFileSync(path.join(root, 'kernel', 'gpu', 'amd.js'), 'utf8')
+test('AMD model fallback stays offline and data-only', () => {
+  const modelSource = fs.readFileSync(path.join(root, 'kernel', 'gpu', 'amd.js'), 'utf8')
+  const pciSource = fs.readFileSync(path.join(root, 'kernel', 'gpu', 'amd_pci.js'), 'utf8')
 
-  assert.doesNotMatch(source, /require\(["'](?:node:)?https?["']\)/)
-  assert.doesNotMatch(source, /require\(["'](?:node:)?child_process["']\)/)
-  assert.doesNotMatch(source, /\b(fetch|axios|rocminfo|hipInfo|ze_info)\b/)
-  assert.doesNotMatch(source, /\b(kfd|topology)\b/i)
+  assert.doesNotMatch(modelSource, /require\(["'](?:node:)?https?["']\)/)
+  assert.doesNotMatch(modelSource, /require\(["'](?:node:)?child_process["']\)/)
+  assert.doesNotMatch(modelSource, /\b(fetch|axios|rocminfo|hipInfo|ze_info)\b/)
+  assert.doesNotMatch(modelSource, /\b(kfd|topology)\b/i)
+  assert.doesNotMatch(pciSource, /require\(["'](?:node:)?https?["']\)/)
+  assert.doesNotMatch(pciSource, /\b(fetch|axios|OpenCL|rocminfo|hipInfo)\b/i)
 })