@fin14/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Aguiar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,197 @@
+# @fin14/core
+
+Measurement engine for the [fin14](https://www.npmjs.com/package/fin14) performance budget CLI. Loads config, measures gzip-compressed page weight against the 14 kB limit, and summarizes results across a static site.
+
+Use this package to integrate fin14 measurement into your own build scripts, CI pipelines, or framework tooling. If you just want a CLI, install `fin14` directly.
+
+## Install
+
+```
+npm install @fin14/core
+```
+
+Requires Node.js >= 22. ESM only.
+
+## Usage
+
+### Measure a single page
+
+```js
+import { loadConfig, measurePage } from '@fin14/core';
+import path from 'node:path';
+
+const config = await loadConfig({ outputDir: './dist' });
+const result = await measurePage(path.resolve('./dist/index.html'), config);
+
+console.log(result.status);      // 'pass' | 'warn' | 'fail'
+console.log(result.totalBytes);  // compressed bytes
+console.log(result.overBudget);  // boolean
+```
+
+### Measure a whole site with progress callback
+
+```js
+import { loadConfig, measureSite } from '@fin14/core';
+
+const config = await loadConfig();
+
+const summary = await measureSite('./dist', config, {
+  onStart({ total, files }) {
+    console.log(`Measuring ${total} pages...`);
+  },
+  onPageResult(page, { done, total }) {
+    console.log(`[${done}/${total}] ${page.file} — ${page.status}`);
+  },
+});
+
+console.log(`${summary.pass} pass, ${summary.warn} warn, ${summary.fail} fail`);
+```
+
+## API
+
+### `loadConfig(options?)`
+
+```js
+async function loadConfig(options = {})
+```
+
+Loads and merges configuration from `fin14.toml`, applying all defaults. If no config file is found, defaults are used — `fin14.toml` is optional.
+
+| Option | Type | Description |
+|---|---|---|
+| `config` | `string` | Path to `fin14.toml`. Auto-searches current directory if omitted. |
+| `outputDir` | `string` | Overrides `project.output_dir` from the config file. |
+
+Returns the full merged config object. Throws on parse errors or unknown fields in `fin14.toml`.
+
+---
+
+### `measurePage(file, config)`
+
+```js
+async function measurePage(file, config)
+```
+
+Measures a single HTML page and all its linked resources.
+
+| Param | Type | Description |
+|---|---|---|
+| `file` | `string` | Absolute path to the `.html` file. |
+| `config` | `object` | Result of `loadConfig()`. |
+
+Returns a `PageResult`:
+
+```js
+{
+  file: string,                  // relative path from outputDir
+  status: 'pass' | 'warn' | 'fail',
+  totalBytes: number,            // compressed bytes
+  limitBytes: number,            // budget limit in bytes
+  overBudget: boolean,
+  unknownBudget: boolean,
+  resources: ResourceResult[],
+  cutCandidates: ResourceResult[],
+  warnings: Warning[],
+  skippedResources: SkippedResource[]
+}
+```
+
+---
+
+### `measureSite(outputDir, config, options?)`
+
+```js
+async function measureSite(outputDir, config, options = {})
+```
+
+Discovers and measures all HTML pages under `outputDir`, after applying
+`project.include` / `project.exclude` glob filters from the config. Each page is
+validated against its resolved budget (`budget.overrides` first-match, else
+`budget.default`).
+
+| Param | Type | Description |
+|---|---|---|
+| `outputDir` | `string` | Path to the SSG output folder. |
+| `config` | `object` | Result of `loadConfig()`. |
+| `options.onStart` | `function` | Called once before measurement starts. Receives `{ total: number, files: string[] }`. |
+| `options.onPageResult` | `function` | Called after each page. Receives `(PageResult, { done: number, total: number })`. |
+
+Returns a `SiteSummary`.
+
+---
+
+### `summarize(results, outputDir, siteWarnings?)`
+
+```js
+function summarize(results, outputDir, siteWarnings = [])
+```
+
+Aggregates an array of `PageResult` objects into a `SiteSummary`. Useful when you run `measurePage` yourself and want to produce a summary.
+
+| Param | Type | Description |
+|---|---|---|
+| `results` | `PageResult[]` | Results from `measurePage`. |
+| `outputDir` | `string` | Path to the output directory. |
+| `siteWarnings` | `Warning[]` | Site-level warnings (e.g. EMFILE retry). |
+
+Returns a `SiteSummary`:
+
+```js
+{
+  outputDir: string,
+  generatedAt: string,           // ISO timestamp
+  pages: number,
+  pass: number,
+  warn: number,
+  fail: number,
+  totalBytes: number,
+  topAssets: ResourceResult[],
+  siteWarnings: Warning[],
+  results: PageResult[]
+}
+```
+
+### Glob helpers
+
+```js
+import { matchGlob, filterPages, resolveBudget } from '@fin14/core';
+```
+
+| Function | Description |
+|---|---|
+| `matchGlob(path, pattern)` | Anchored glob match (`*`, `**`, `?`) against a posix path. |
+| `filterPages(relPaths, config)` | Applies `project.include` / `project.exclude` to a list of relative page paths. |
+| `resolveBudget(relFile, config)` | Returns the budget in bytes for a page — first matching `budget.overrides[].path`, else `budget.default`. |
+
+## Types
+
+### `ResourceResult`
+
+```js
+{
+  key: string,           // dedup key (absolute path or URL)
+  type: 'html' | 'css' | 'js' | 'image' | 'font',
+  group: 'html' | 'css' | 'js' | 'images' | 'external',
+  path: string,          // absolute path or URL
+  displayPath: string,   // path shown in output (relative to outputDir)
+  external: boolean,
+  inline: boolean,
+  bytes: number          // compressed bytes
+}
+```
+
+### `Warning`
+
+```js
+{
+  code: string,          // e.g. 'E14'
+  message: string,
+  strictFailure: boolean
+}
+```
+
+---
+
+For the CLI, see [fin14](https://www.npmjs.com/package/fin14).
+
+MIT

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@fin14/core",
+  "version": "0.1.0",
+  "description": "fin14 measurement engine",
+  "type": "module",
+  "license": "MIT",
+  "author": "duxpe",
+  "homepage": "https://github.com/duxpe/fin14#readme",
+  "bugs": { "url": "https://github.com/duxpe/fin14/issues" },
+  "keywords": ["performance", "budget", "static-site", "14kb", "measurement", "compression", "web-performance", "page-weight", "ssg"],
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "git+https://github.com/duxpe/fin14.git" },
+  "engines": { "node": ">=22.0.0" },
+  "exports": { ".": "./src/index.js" },
+  "files": ["src", "README.md", "LICENSE"],
+  "scripts": { "test": "node --test" },
+  "dependencies": {
+    "parse5": "^8.0.1",
+    "css-tree": "^3.2.1",
+    "smol-toml": "^1.6.1"
+  }
+}

package/src/budget/collector.js

@@ -0,0 +1,288 @@
+import { readFile } from 'node:fs/promises'
+import { resolve, relative, dirname } from 'node:path'
+import { parse } from 'parse5'
+import { parse as parseCss, walk as walkCss } from 'css-tree'
+
+function walk(node, fn) {
+  fn(node)
+  if (node.childNodes) node.childNodes.forEach(c => walk(c, fn))
+}
+
+function attr(node, name) {
+  return node.attrs?.find(a => a.name === name)?.value
+}
+
+function textContent(node) {
+  if (!node.childNodes) return ''
+  return node.childNodes
+    .filter(c => c.nodeName === '#text')
+    .map(c => c.value)
+    .join('')
+}
+
+function resolveUrl(href, baseFile, outputDir) {
+  if (href.startsWith('http://') || href.startsWith('https://')) {
+    const u = new URL(href)
+    u.hash = ''
+    const key = u.href
+    const displayPath = u.hostname + u.pathname
+    return { external: true, key, path: href, displayPath }
+  }
+  let absPath
+  if (href.startsWith('/')) {
+    absPath = resolve(outputDir, href.slice(1))
+  } else {
+    absPath = resolve(dirname(baseFile), href)
+  }
+  const hashIdx = absPath.indexOf('#')
+  const queryIdx = absPath.indexOf('?')
+  const cutIdx = [hashIdx, queryIdx].filter(i => i !== -1).reduce((a, b) => Math.min(a, b), absPath.length)
+  const key = absPath.slice(0, cutIdx)
+  return { external: false, key, path: key, displayPath: relative(outputDir, key) }
+}
+
+function typeFromAs(asVal) {
+  if (asVal === 'script') return 'js'
+  if (asVal === 'style') return 'css'
+  if (asVal === 'image') return 'image'
+  if (asVal === 'font') return 'font'
+  return null
+}
+
+function groupFromType(type, external) {
+  if (external) return 'external'
+  if (type === 'html') return 'html'
+  if (type === 'css') return 'css'
+  if (type === 'js') return 'js'
+  if (type === 'image') return 'images'
+  if (type === 'font') return 'css'
+  return 'external'
+}
+
+function extractCssImportUrl(node) {
+  const prelude = node.prelude
+  if (!prelude) return null
+  let url = null
+  walkCss(prelude, n => {
+    if (url) return
+    if (n.type === 'String') {
+      url = n.value.replace(/^['"]|['"]$/g, '')
+    } else if (n.type === 'Url') {
+      const val = n.value
+      if (val.type === 'String') {
+        url = val.value.replace(/^['"]|['"]$/g, '')
+      } else if (val.type === 'Raw') {
+        url = val.value
+      }
+    }
+  })
+  return url
+}
+
+function extractFontFaceSrc(node) {
+  const results = []
+  if (!node.block) return results
+  walkCss(node.block, decl => {
+    if (decl.type !== 'Declaration' || decl.property !== 'src') return
+    const urls = []
+    walkCss(decl.value, n => {
+      if (n.type === 'Url') {
+        const val = n.value
+        let href = ''
+        if (typeof val === 'string') {
+          href = val.replace(/^['"]|['"]$/g, '')
+        } else if (val && val.type === 'String') {
+          href = val.value.replace(/^['"]|['"]$/g, '')
+        } else if (val && val.type === 'Raw') {
+          href = val.value
+        }
+        if (href) urls.push(href)
+      }
+    })
+    results.push(...urls)
+  })
+  return results
+}
+
+function addRef(resolved, type, group, seenKeys, refs, skipped) {
+  if (seenKeys.has(resolved.key)) {
+    skipped.push({ key: resolved.key, type, displayPath: resolved.displayPath, reason: 'duplicate', countedAs: seenKeys.get(resolved.key) })
+  } else {
+    seenKeys.set(resolved.key, group)
+    refs.push({ key: resolved.key, type, group, path: resolved.path, displayPath: resolved.displayPath, external: resolved.external, inline: false })
+  }
+}
+
+// stack: Set of abs paths currently in the import chain — used only for cycle detection.
+// seenKeys handles dedup (already counted → skip as duplicate, not a cycle).
+async function processCss(cssContent, cssFile, outputDir, seenKeys, refs, skipped, warnings, stack, htmlFile) {
+  const ast = parseCss(cssContent, { parseValue: true, onParseError: () => {} })
+  const baseFile = cssFile || htmlFile
+  const imports = []
+
+  walkCss(ast, {
+    visit: 'Atrule',
+    enter(node) {
+      if (node.name === 'import') {
+        const href = extractCssImportUrl(node)
+        if (!href || href.startsWith('http://') || href.startsWith('https://')) return
+        imports.push(href)
+      } else if (node.name === 'font-face') {
+        const urls = extractFontFaceSrc(node)
+        for (let i = 0; i < urls.length; i++) {
+          const href = urls[i]
+          const resolved = resolveUrl(href, baseFile, outputDir)
+          const type = 'font'
+          const group = groupFromType(type, resolved.external)
+          if (i === 0) {
+            addRef(resolved, type, group, seenKeys, refs, skipped)
+          } else {
+            skipped.push({ key: resolved.key, type, displayPath: resolved.displayPath, reason: 'alternate_font_src' })
+          }
+        }
+      }
+    }
+  })
+
+  for (const href of imports) {
+    const absPath = resolve(dirname(baseFile), href)
+
+    if (stack.has(absPath)) {
+      warnings.push({ code: 'E11', message: `CSS @import cycle detected: ${absPath}`, path: absPath, strictFailure: false })
+      continue
+    }
+
+    let content
+    try {
+      content = await readFile(absPath, 'utf8')
+    } catch {
+      warnings.push({ code: 'E10', message: `CSS @import file not found: ${absPath}`, path: absPath, strictFailure: false })
+      continue
+    }
+
+    const displayPath = relative(outputDir, absPath)
+    if (!seenKeys.has(absPath)) {
+      seenKeys.set(absPath, 'css')
+      refs.push({ key: absPath, type: 'css', group: 'css', path: absPath, displayPath, external: false, inline: false })
+      await processCss(content, absPath, outputDir, seenKeys, refs, skipped, warnings, new Set([...stack, absPath]), htmlFile)
+    } else {
+      skipped.push({ key: absPath, type: 'css', displayPath, reason: 'duplicate', countedAs: seenKeys.get(absPath) })
+    }
+  }
+}
+
+export async function collect(htmlFile, outputDir, config) {
+  const refs = []
+  const skipped = []
+  const warnings = []
+  const seenKeys = new Map()
+
+  const htmlBuffer = await readFile(htmlFile)
+  seenKeys.set(htmlFile, 'html')
+  refs.push({
+    key: htmlFile,
+    type: 'html',
+    group: 'html',
+    path: htmlFile,
+    displayPath: relative(outputDir, htmlFile),
+    external: false,
+    inline: true,
+    inlineContent: htmlBuffer,
+  })
+
+  const dom = parse(htmlBuffer.toString('utf8'))
+  const vp = config.viewport[config.viewport.default]
+  const maxLazy = vp.lazy_visible_images
+  let lazyCount = 0
+  const cssQueue = []
+
+  walk(dom, node => {
+    if (node.nodeName === 'link') {
+      const rel = attr(node, 'rel')
+      const href = attr(node, 'href')
+      if (!href) return
+
+      if (rel === 'stylesheet') {
+        const resolved = resolveUrl(href, htmlFile, outputDir)
+        addRef(resolved, 'css', groupFromType('css', resolved.external), seenKeys, refs, skipped)
+        if (!resolved.external) cssQueue.push({ absPath: resolved.key, inline: false })
+      } else if (rel === 'preload') {
+        const type = typeFromAs(attr(node, 'as'))
+        if (!type) return
+        const resolved = resolveUrl(href, htmlFile, outputDir)
+        addRef(resolved, type, groupFromType(type, resolved.external), seenKeys, refs, skipped)
+      } else if (rel === 'modulepreload') {
+        const resolved = resolveUrl(href, htmlFile, outputDir)
+        addRef(resolved, 'js', groupFromType('js', resolved.external), seenKeys, refs, skipped)
+      }
+    } else if (node.nodeName === 'style') {
+      // inline CSS bytes are part of HTML — parse for @import/@font-face discovery only
+      cssQueue.push({ inline: true, content: textContent(node) })
+    } else if (node.nodeName === 'script') {
+      const src = attr(node, 'src')
+      const type = attr(node, 'type')
+      if (src && (type === undefined || type === null || type === 'module' || type === 'text/javascript')) {
+        const resolved = resolveUrl(src, htmlFile, outputDir)
+        addRef(resolved, 'js', groupFromType('js', resolved.external), seenKeys, refs, skipped)
+      }
+      // inline scripts: bytes are part of HTML, not counted separately
+    } else if (node.nodeName === 'img') {
+      const src = attr(node, 'src')
+      const srcset = attr(node, 'srcset')
+      const loading = attr(node, 'loading')
+
+      if (srcset) {
+        const resolved = resolveUrl(srcset.split(/[\s,]+/)[0], htmlFile, outputDir)
+        skipped.push({ key: resolved.key, type: 'image', displayPath: resolved.displayPath, reason: 'srcset_alternative' })
+      }
+
+      if (src) {
+        if (loading === 'lazy') {
+          if (lazyCount < maxLazy) {
+            lazyCount++
+            const resolved = resolveUrl(src, htmlFile, outputDir)
+            addRef(resolved, 'image', groupFromType('image', resolved.external), seenKeys, refs, skipped)
+          } else {
+            const resolved = resolveUrl(src, htmlFile, outputDir)
+            skipped.push({ key: resolved.key, type: 'image', displayPath: resolved.displayPath, reason: 'outside_matrix' })
+          }
+        } else {
+          const resolved = resolveUrl(src, htmlFile, outputDir)
+          addRef(resolved, 'image', groupFromType('image', resolved.external), seenKeys, refs, skipped)
+        }
+      }
+    } else if (node.nodeName === 'source') {
+      const srcset = attr(node, 'srcset')
+      if (srcset) {
+        const firstSrc = srcset.split(/[\s,]+/).find(s => s && !s.includes('w') && !s.includes('x')) || srcset.split(/[\s,]+/)[0]
+        if (firstSrc) {
+          const resolved = resolveUrl(firstSrc, htmlFile, outputDir)
+          skipped.push({ key: resolved.key, type: 'image', displayPath: resolved.displayPath, reason: 'srcset_alternative' })
+        }
+      }
+    }
+  })
+
+  // processedCss tracks which CSS files' content has been parsed for @imports.
+  // Separate from seenKeys (which tracks counted refs) — prevents re-parsing the same
+  // file if it appears multiple times in the HTML (e.g., duplicate <link> tags).
+  const processedCss = new Set()
+
+  for (const item of cssQueue) {
+    if (item.inline) {
+      await processCss(item.content, null, outputDir, seenKeys, refs, skipped, warnings, new Set(), htmlFile)
+    } else {
+      if (processedCss.has(item.absPath)) continue
+      processedCss.add(item.absPath)
+      let content
+      try {
+        content = await readFile(item.absPath, 'utf8')
+      } catch {
+        continue
+      }
+      await processCss(content, item.absPath, outputDir, seenKeys, refs, skipped, warnings, new Set([item.absPath]), htmlFile)
+    }
+  }
+
+  return { refs, skipped, warnings }
+}

package/src/budget/external.js

@@ -0,0 +1,96 @@
+import { createHash } from 'node:crypto'
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import {
+  DEFAULT_CONFIG,
+  EXTERNAL_CACHE_TTL_SECONDS,
+  EXTERNAL_DOMAIN_CONCURRENCY,
+  EXTERNAL_DOMAIN_WAIT_MS,
+  MILLISECONDS_PER_SECOND,
+} from '../constants.js'
+
+function cacheDir() {
+  return join(process.cwd(), '.fin14', 'cache')
+}
+
+function urlKey(url) {
+  return createHash('sha1').update(url).digest('hex')
+}
+
+async function readCache(url) {
+  const dir = cacheDir()
+  const key = urlKey(url)
+  try {
+    const meta = JSON.parse(await readFile(join(dir, `${key}.json`), 'utf8'))
+    if (Math.floor(Date.now() / MILLISECONDS_PER_SECOND) - meta.cachedAt > EXTERNAL_CACHE_TTL_SECONDS) return null
+    const body = await readFile(join(dir, `${key}.body`))
+    return { body, status: meta.status, contentType: meta.contentType }
+  } catch {
+    return null
+  }
+}
+
+async function writeCache(url, body, status, contentType) {
+  const dir = cacheDir()
+  await mkdir(dir, { recursive: true })
+  const key = urlKey(url)
+  const meta = { url, cachedAt: Math.floor(Date.now() / MILLISECONDS_PER_SECOND), status, contentType }
+  await writeFile(join(dir, `${key}.body`), body)
+  await writeFile(join(dir, `${key}.json`), JSON.stringify(meta))
+}
+
+const domainCounts = new Map()
+
+async function withDomainLimit(hostname, fn) {
+  while ((domainCounts.get(hostname) ?? 0) >= EXTERNAL_DOMAIN_CONCURRENCY) {
+    await new Promise(r => setTimeout(r, EXTERNAL_DOMAIN_WAIT_MS))
+  }
+  domainCounts.set(hostname, (domainCounts.get(hostname) ?? 0) + 1)
+  try { return await fn() }
+  finally { domainCounts.set(hostname, domainCounts.get(hostname) - 1) }
+}
+
+export async function fetchExternal(url, config) {
+  const cached = await readCache(url)
+  if (cached) return cached
+
+  const hostname = new URL(url).hostname
+  return withDomainLimit(hostname, async () => {
+    const timeoutMs = config?.network?.timeout_ms ?? DEFAULT_CONFIG.network.timeout_ms
+    const maxRedirects = config?.network?.max_redirects ?? DEFAULT_CONFIG.network.max_redirects
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+
+    try {
+      let redirectCount = 0
+      let currentUrl = url
+      let res
+
+      while (true) {
+        res = await fetch(currentUrl, { redirect: 'manual', signal: controller.signal })
+        if (res.status >= 300 && res.status < 400) {
+          if (++redirectCount > maxRedirects) throw new Error('too many redirects')
+          const location = res.headers.get('location')
+          if (!location) throw new Error('redirect missing location header')
+          currentUrl = new URL(location, currentUrl).href
+          continue
+        }
+        break
+      }
+
+      if (res.status < 200 || res.status >= 300) {
+        throw new Error(`HTTP ${res.status}`)
+      }
+
+      const body = Buffer.from(await res.arrayBuffer())
+      const contentType = res.headers.get('content-type') ?? ''
+      await writeCache(url, body, res.status, contentType)
+      return { body, status: res.status, contentType }
+    } catch (err) {
+      if (err.name === 'AbortError') throw new Error(`timeout fetching ${url}`)
+      throw err
+    } finally {
+      clearTimeout(timer)
+    }
+  })
+}

package/src/budget/measurer.js

@@ -0,0 +1,68 @@
+import { readFile } from 'node:fs/promises'
+import { compress } from '../compress.js'
+import { fetchExternal } from './external.js'
+
+const MISSING_CODE = {
+  css: 'E06',
+  js: 'E07',
+  image: 'E08',
+  font: 'E08',
+}
+
+export async function measure(refs, config) {
+  const results = []
+  const warnings = []
+  let unknownBudget = false
+
+  for (const ref of refs) {
+    let bytes
+
+    if (ref.inline) {
+      bytes = compress(ref.inlineContent, config.budget)
+    } else if (ref.external) {
+      try {
+        const { body } = await fetchExternal(ref.path, config)
+        bytes = compress(body, config.budget)
+      } catch {
+        warnings.push({
+          code: 'E09',
+          message: `${ref.displayPath}: fetch failed — budget unknown`,
+          path: ref.path,
+          strictFailure: false,
+        })
+        warnings.push({
+          code: 'E19',
+          message: `unknown budget: fetch failed for ${ref.displayPath}`,
+          path: ref.path,
+          strictFailure: true,
+        })
+        unknownBudget = true
+        continue
+      }
+    } else {
+      try {
+        const content = await readFile(ref.path)
+        bytes = compress(content, config.budget)
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          const code = MISSING_CODE[ref.type]
+          if (code) {
+            warnings.push({
+              code,
+              message: `${ref.displayPath}: file not found`,
+              path: ref.path,
+              strictFailure: false,
+            })
+          }
+          continue
+        }
+        throw err
+      }
+    }
+
+    const { inlineContent: _, ...rest } = ref
+    results.push({ ...rest, bytes })
+  }
+
+  return { results, warnings, unknownBudget }
+}