@adea-ai/plugins 4.0.0 → 4.0.6

package/src/site-icons.test.ts

@@ -32,7 +32,6 @@ function fetcher(site: Record<string, string | Uint8Array>): SiteIconFetcher & {
   return {
     textCalls,
     byteCalls,
-    digest: (bytes) => byteDigest(bytes),
     fetchText: async (url) => {
       textCalls.push(url)
       const value = site[url]
@@ -96,6 +95,68 @@ describe('site icon discovery', () => {
     ])
   })
 
+  test('resolves relative icon links against the first document base URL', () => {
+    const baseHtml = `<!-- <base href="https://ignored.example/"> <script> -->
+      <script>const sample = '<!-- <base href="https://script.example/">'</script>
+      <meta content="<base href='https://attribute.example/'>">
+      <base target="_blank"><base href="/assets/icons/">
+      <base href="https://later.example/">
+      <link rel="icon" href="mark.png">`
+    expect(discoverSiteIcons(baseHtml, 'https://vendor.example/docs/page')).toEqual([
+      'https://vendor.example/assets/icons/mark.png',
+      'https://vendor.example/favicon.ico',
+    ])
+  })
+
+  test('ignores bases and links inside text and template content', () => {
+    for (const inert of [
+      '<title><base href="https://title.example/"></title>',
+      '<textarea><base href="https://textarea.example/"></textarea>',
+      `<template><template><base href="https://nested.example/"></template>
+        <link rel="icon" href="https://template.example/icon.png"></template>`,
+    ]) {
+      expect(
+        discoverSiteIcons(
+          `${inert}<base href="/real/"><link rel="icon" href="mark.png">`,
+          'https://vendor.example/'
+        )
+      ).toEqual(['https://vendor.example/real/mark.png', 'https://vendor.example/favicon.ico'])
+    }
+  })
+
+  test('decodes HTML character references in URLs', () => {
+    expect(
+      discoverSiteIcons(
+        '<base href="/icons/?a=1&amp;b=2"><link rel="icon" href="mark.png?x=1&amp;y=2">',
+        'https://vendor.example/'
+      )
+    ).toEqual([
+      'https://vendor.example/icons/mark.png?x=1&y=2',
+      'https://vendor.example/favicon.ico',
+    ])
+  })
+
+  test('retains the homepage fallback and URL policy with a document base', () => {
+    expect(
+      discoverSiteIcons(
+        '<base href="https://cdn.example/icons/"><link rel="icon" href="mark.png">',
+        'https://vendor.example/docs/page'
+      )
+    ).toEqual(['https://cdn.example/icons/mark.png', 'https://vendor.example/favicon.ico'])
+    expect(
+      discoverSiteIcons(
+        '<base href="http://vendor.example/assets/"><link rel="icon" href="mark.png">',
+        'https://vendor.example/docs/page'
+      )
+    ).toEqual(['https://vendor.example/favicon.ico'])
+    expect(
+      discoverSiteIcons(
+        '<base href="http://["><base href="/later/"><link rel="icon" href="mark.png">',
+        'https://vendor.example/docs/page'
+      )
+    ).toEqual(['https://vendor.example/docs/mark.png', 'https://vendor.example/favicon.ico'])
+  })
+
   test('prefers the larger declared size within a group', () => {
     const sizes = `<link rel="icon" sizes="32x32" href="/small.png">
       <link rel="icon" sizes="512x512" href="/large.png">`
@@ -163,6 +224,17 @@ describe('site icon resolution', () => {
     expect(io.byteCalls).toEqual(['https://vendor.example/apple-icon.png'])
   })
 
+  test('fetches a relative icon from the document base', async () => {
+    const page = 'https://vendor.example/docs/page'
+    const baseHtml = '<head><base href="/assets/"><link rel="icon" href="mark.png"></head>'
+    const io = fetcher({ [page]: baseHtml, 'https://vendor.example/assets/mark.png': PNG })
+    expect(await resolveSiteIcon(page, io)).toMatchObject({
+      url: 'https://vendor.example/assets/mark.png',
+      homepage: page,
+    })
+    expect(io.byteCalls).toEqual(['https://vendor.example/assets/mark.png'])
+  })
+
   test('accepts an icon container and skips a candidate that fails inspection', async () => {
     const ico = fetcher({ [homepage]: html, 'https://vendor.example/apple-icon.png': ICO })
     expect(await resolveSiteIcon(homepage, ico)).toMatchObject({ contentType: 'image/x-icon' })

package/src/site-icons.ts

@@ -1,3 +1,5 @@
+import { parseFragment, type DefaultTreeAdapterTypes } from 'parse5'
+import { byteDigest } from './digest.js'
 import { inspectIconBytes, MAX_ICON_BYTES, type IconContentType } from './icons.js'
 
 /**
@@ -5,8 +7,8 @@ import { inspectIconBytes, MAX_ICON_BYTES, type IconContentType } from './icons.
  *
  * Many plugins are a thin wrapper over a vendor's API: the content carries no
  * logo, and the declared homepage is the only pointer to the vendor. Fetching
- * that site's icon once at publish time, verifying it and mirroring it as a
- * release asset replaces a per-render favicon lookup in the client.
+ * that site's icon once at publish time, verifying it and mirroring it beside
+ * the catalog replaces a per-render favicon lookup in the client.
  */
 export const SITE_ICON_MAX_HTML_BYTES = 4 * 1024 * 1024
 
@@ -76,19 +78,35 @@ export function isPublicHostname(hostname: string): boolean {
  * `apple-touch-icon` is preferred because it is a square PNG sized for a home
  * screen; declared `icon` links follow in declared order; `/favicon.ico` is the
  * conventional last resort when nothing is declared.
+ * Relative links use the document's first base href when present; the fallback
+ * stays on the homepage origin.
  */
 export function discoverSiteIcons(html: string, baseUrl: string): readonly string[] {
   const candidates: { href: string; rank: number }[] = []
-  const linkTags = html.match(/<link(?=[ \t\r\n\f/>])(?:"[^"]*"|'[^']*'|[^'">])*>/gi) ?? []
-  for (const tag of linkTags) {
-    const attributes = new Map<string, string>()
-    for (const attribute of tag.matchAll(
-      /\s+([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g
-    )) {
-      const name = attribute[1]!.toLowerCase()
-      if (!attributes.has(name))
-        attributes.set(name, attribute[2] ?? attribute[3] ?? attribute[4] ?? '')
+  const elements: DefaultTreeAdapterTypes.Element[] = []
+  const nodes: DefaultTreeAdapterTypes.ChildNode[] = parseFragment(html).childNodes.toReversed()
+  while (nodes.length > 0) {
+    const node = nodes.pop()!
+    if (!('tagName' in node)) continue
+    if (node.namespaceURI === 'http://www.w3.org/1999/xhtml') elements.push(node)
+    // Template contents are a separate, inert document fragment.
+    if (node.tagName !== 'template') nodes.push(...node.childNodes.toReversed())
+  }
+  let resolutionBase = baseUrl
+  for (const element of elements) {
+    if (element.tagName !== 'base') continue
+    const attributes = new Map(element.attrs.map(({ name, value }) => [name, value]))
+    if (!attributes.has('href')) continue
+    try {
+      resolutionBase = new URL(attributes.get('href')!, baseUrl).toString()
+    } catch {
+      // An invalid first base falls back to the document URL.
     }
+    break
+  }
+  for (const element of elements) {
+    if (element.tagName !== 'link') continue
+    const attributes = new Map(element.attrs.map(({ name, value }) => [name, value]))
     const rel = new Set((attributes.get('rel') ?? '').toLowerCase().split(/\s+/))
     if (
       !['apple-touch-icon', 'apple-touch-icon-precomposed', 'icon', 'mask-icon'].some((name) =>
@@ -112,7 +130,7 @@ export function discoverSiteIcons(html: string, baseUrl: string): readonly strin
   const resolved: { url: string; rank: number }[] = []
   for (const candidate of candidates.toSorted((left, right) => left.rank - right.rank)) {
     try {
-      const url = new URL(candidate.href, baseUrl)
+      const url = new URL(candidate.href, resolutionBase)
       if (url.protocol !== 'https:' || !isPublicHostname(url.hostname)) continue
       resolved.push({ url: url.toString(), rank: candidate.rank })
     } catch {
@@ -134,7 +152,6 @@ export function discoverSiteIcons(html: string, baseUrl: string): readonly strin
 export interface SiteIconFetcher {
   readonly fetchText: (url: string) => Promise<string>
   readonly fetchBytes: (url: string) => Promise<Uint8Array>
-  readonly digest: (bytes: Uint8Array) => string
 }
 
 /**
@@ -171,7 +188,7 @@ export async function resolveSiteIcon(
       homepage,
       bytes,
       contentType: inspected.contentType,
-      digest: fetcher.digest(bytes),
+      digest: byteDigest(bytes),
     }
   }
   return { failed: 'NO_USABLE_ICON' }

package/src/snapshots.ts

@@ -0,0 +1,287 @@
+import { promises as fs } from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+import { Readable } from 'node:stream'
+import { createGunzip } from 'node:zlib'
+import { extract } from 'tar-stream'
+import type { CatalogPolicy } from './policy.js'
+import { PluginSafetyError } from './plugin-skips.js'
+import { canonicalRepositoryUrl, safeRelativePath, type SourceConfig } from './sources.js'
+import { fetchUpstream, GITHUB_REPOSITORY_HOSTS, upstreamRequestHeaders } from './upstream.js'
+
+export interface Snapshot {
+  readonly files: ReadonlyMap<string, Uint8Array>
+  readonly symlinks: readonly string[]
+}
+
+export interface SnapshotLoader {
+  load(repositoryUrl: string, commitSha: string, pluginSubdirectory: string): Promise<Snapshot>
+}
+
+/**
+ * Ceiling on bytes read out of one repository archive.
+ *
+ * The per-plugin policy still bounds what any single plugin may contain; this
+ * only stops a decompression bomb from exhausting the build host, and it is
+ * enforced while the stream is read rather than after it is buffered.
+ */
+const MAX_ARCHIVE_BYTES = 512 * 1024 * 1024
+
+function concatChunks(chunks: readonly Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  return out
+}
+
+/**
+ * Read one GitHub repository tarball into path -> bytes.
+ *
+ * GitHub wraps every entry in a single top-level `<repo>-<sha>/` directory,
+ * which is stripped so the keys match the tree API's repository-relative
+ * paths. Only regular files are taken: directories, symlinks, hardlinks and
+ * the `pax_global_header` record are skipped, so a link can never be
+ * materialized as content. Every remaining path goes through
+ * `safeRelativePath`, so an archive that tries to escape the repository is
+ * rejected rather than partially trusted. This is a whole-repository archive
+ * shared across plugins, so an oversized unrelated file is drained and
+ * counted against the archive budget but not retained. The selected plugin's
+ * files are checked against the tree before the archive is fetched and again
+ * when its snapshot is validated.
+ */
+export async function readArchiveFiles(
+  archive: Uint8Array,
+  policy: CatalogPolicy
+): Promise<Map<string, Uint8Array>> {
+  const files = new Map<string, Uint8Array>()
+  let totalBytes = 0
+  const parser = extract()
+  const gunzip = createGunzip()
+  const settled = new Promise<void>((resolveDone, rejectDone) => {
+    const fail = (error: unknown): void => {
+      gunzip.destroy()
+      parser.destroy()
+      rejectDone(error)
+    }
+    parser.on('entry', (header, stream, next) => {
+      const skip = (): void => {
+        stream.on('end', next)
+        stream.resume()
+      }
+      if (header.type !== 'file') return skip()
+      const segments = header.name.split('/')
+      if (segments.length < 2) return skip()
+      let path: string
+      try {
+        path = safeRelativePath(segments.slice(1).join('/'), 'TREE_PATH_INVALID')
+      } catch (error) {
+        return fail(error)
+      }
+      const chunks: Uint8Array[] = []
+      let length = 0
+      stream.on('data', (chunk: unknown) => {
+        const bytes = chunk as Uint8Array
+        length += bytes.byteLength
+        if (totalBytes + length > MAX_ARCHIVE_BYTES) {
+          fail(new Error('PLUGIN_SIZE_POLICY: archive'))
+          return
+        }
+        if (length <= policy.maxFileBytes) chunks.push(bytes)
+        else chunks.length = 0
+      })
+      stream.on('error', fail)
+      stream.on('end', () => {
+        try {
+          totalBytes += length
+          if (length <= policy.maxFileBytes) files.set(path, concatChunks(chunks, length))
+          next()
+        } catch (error) {
+          fail(error)
+        }
+      })
+      stream.resume()
+    })
+    parser.on('error', fail)
+    gunzip.on('error', fail)
+    parser.on('finish', () => resolveDone())
+  })
+  Readable.from([archive]).pipe(gunzip).pipe(parser)
+  await settled
+  return files
+}
+
+export class NetworkSnapshotLoader implements SnapshotLoader {
+  readonly #policy: CatalogPolicy
+  readonly #trees = new Map<string, Promise<readonly TreeEntry[]>>()
+  readonly #archives = new Map<string, Promise<ReadonlyMap<string, Uint8Array>>>()
+
+  constructor(policy: CatalogPolicy) {
+    this.#policy = policy
+  }
+
+  async load(
+    repositoryUrl: string,
+    commitSha: string,
+    pluginSubdirectory: string
+  ): Promise<Snapshot> {
+    const parsed = new URL(canonicalRepositoryUrl(repositoryUrl))
+    if (!GITHUB_REPOSITORY_HOSTS.includes(parsed.hostname))
+      throw new Error(`GIT_HOST_UNSUPPORTED: ${parsed.hostname}`)
+    const [owner, repo] = parsed.pathname.split('/').filter(Boolean)
+    if (!owner || !repo) throw new Error('GIT_REPOSITORY_INVALID')
+    const key = `${owner}/${repo}@${commitSha}`
+    let pendingTree = this.#trees.get(key)
+    if (!pendingTree) {
+      pendingTree = (async () => {
+        const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${commitSha}?recursive=1`
+        const response = await fetchUpstream(treeUrl, {
+          headers: upstreamRequestHeaders(treeUrl),
+        })
+        if (!response.ok)
+          throw new PluginSafetyError('PLUGIN_SOURCE_UNAVAILABLE', [`${owner}/${repo}`])
+        const payload = (await response.json()) as { truncated?: boolean; tree?: TreeEntry[] }
+        if (payload.truncated) throw new Error(`GIT_TREE_TRUNCATED: ${owner}/${repo}@${commitSha}`)
+        return (payload.tree ?? []).map((entry) => ({
+          ...entry,
+          path: safeRelativePath(entry.path, 'TREE_PATH_INVALID'),
+        }))
+      })().catch((error: unknown) => {
+        this.#trees.delete(key)
+        throw error
+      })
+      this.#trees.set(key, pendingTree)
+    }
+    const tree = await pendingTree
+    const prefix = pluginSubdirectory ? `${safeRelativePath(pluginSubdirectory)}/` : ''
+    const submodules = tree.filter(
+      (entry) =>
+        entry.path.startsWith(prefix) && (entry.type === 'commit' || entry.mode === '160000')
+    )
+    if (submodules.length > 0)
+      throw new Error(`GIT_SUBMODULE_UNSUPPORTED: ${repositoryUrl}:${pluginSubdirectory}`)
+    const selected = tree.filter((entry) => entry.type === 'blob' && entry.path.startsWith(prefix))
+    if (selected.length === 0)
+      throw new Error(`PLUGIN_PATH_NOT_FOUND: ${repositoryUrl}:${pluginSubdirectory}`)
+    const files = new Map<string, Uint8Array>()
+    const symlinks = tree
+      .filter((entry) => entry.mode === '120000' && entry.path.startsWith(prefix))
+      .map((entry) => entry.path)
+    if (selected.length > this.#policy.maxFilesPerPlugin) throw new Error('PLUGIN_TOO_MANY_FILES')
+    let totalSize = 0
+    for (const entry of selected) {
+      const size = entry.size ?? 0
+      if (size > this.#policy.maxFileBytes || totalSize + size > this.#policy.maxBytesPerPlugin)
+        throw new Error(`PLUGIN_SIZE_POLICY: ${entry.path}`)
+      totalSize += size
+    }
+    // The tree above already bounded this plugin before a byte was pulled, so
+    // the archive is the only unbounded read left and it is capped while it
+    // streams. One archive per repository replaces one request per file.
+    const archive = await this.#archiveFiles(key, owner, repo, commitSha)
+    for (const entry of selected) {
+      const bytes = archive.get(entry.path)
+      if (!bytes) throw new PluginSafetyError('PLUGIN_FILE_UNAVAILABLE', [entry.path])
+      if (bytes.byteLength > this.#policy.maxFileBytes)
+        throw new Error(`PLUGIN_FILE_TOO_LARGE: ${entry.path}`)
+      files.set(
+        prefix ? relative(prefix.slice(0, -1), entry.path).replaceAll('\\', '/') : entry.path,
+        bytes
+      )
+    }
+    return { files, symlinks }
+  }
+
+  async #archiveFiles(
+    key: string,
+    owner: string,
+    repo: string,
+    commitSha: string
+  ): Promise<ReadonlyMap<string, Uint8Array>> {
+    const cached = this.#archives.get(key)
+    if (cached) return cached
+    const pending = (async () => {
+      const url = `https://api.github.com/repos/${owner}/${repo}/tarball/${commitSha}`
+      const response = await fetchUpstream(url, { headers: upstreamRequestHeaders(url) })
+      if (!response.ok)
+        throw new PluginSafetyError('PLUGIN_SOURCE_UNAVAILABLE', [`${owner}/${repo}`])
+      return readArchiveFiles(new Uint8Array(await response.arrayBuffer()), this.#policy)
+    })().catch((error: unknown) => {
+      this.#archives.delete(key)
+      throw error
+    })
+    this.#archives.set(key, pending)
+    return pending
+  }
+}
+
+interface TreeEntry {
+  readonly path: string
+  readonly mode?: string
+  readonly type?: string
+  readonly size?: number
+}
+
+export class FixtureSnapshotLoader implements SnapshotLoader {
+  readonly #root: string
+  readonly #sources: ReadonlyMap<string, SourceConfig>
+
+  constructor(root: string, sources: readonly SourceConfig[]) {
+    this.#root = resolve(root)
+    this.#sources = new Map(
+      sources.map((source) => [canonicalRepositoryUrl(source.repositoryUrl), source])
+    )
+  }
+
+  async load(
+    repositoryUrl: string,
+    _commitSha: string,
+    pluginSubdirectory: string
+  ): Promise<Snapshot> {
+    const source = this.#sources.get(canonicalRepositoryUrl(repositoryUrl))
+    if (!source?.fixturePath) throw new Error(`FIXTURE_REPOSITORY_NOT_FOUND: ${repositoryUrl}`)
+    return snapshotFromDirectory(join(this.#root, source.fixturePath), pluginSubdirectory)
+  }
+}
+
+export class DirectorySnapshotLoader implements SnapshotLoader {
+  async load(
+    _repositoryUrl: string,
+    _commitSha: string,
+    pluginSubdirectory: string
+  ): Promise<Snapshot> {
+    throw new Error(`DIRECTORY_LOADER_REQUIRES_ROOT: ${pluginSubdirectory}`)
+  }
+}
+
+export async function snapshotFromDirectory(
+  root: string,
+  pluginSubdirectory: string
+): Promise<Snapshot> {
+  const directory = resolve(root, pluginSubdirectory)
+  const files = new Map<string, Uint8Array>()
+  const symlinks: string[] = []
+  const rootStat = await fs.lstat(directory)
+  if (rootStat.isSymbolicLink()) return { files, symlinks: [pluginSubdirectory || '.'] }
+  await walk(directory, directory, files, symlinks)
+  return { files, symlinks }
+}
+
+async function walk(
+  root: string,
+  current: string,
+  files: Map<string, Uint8Array>,
+  symlinks: string[]
+): Promise<void> {
+  for (const entry of await fs.readdir(current, { withFileTypes: true })) {
+    const absolute = join(current, entry.name)
+    const relativePath = safeRelativePath(relative(root, absolute), 'DIRECTORY_PATH_INVALID')
+    if (entry.isSymbolicLink()) {
+      symlinks.push(relativePath)
+      continue
+    }
+    if (entry.isDirectory()) await walk(root, absolute, files, symlinks)
+    else if (entry.isFile()) files.set(relativePath, await fs.readFile(absolute))
+  }
+}

package/src/source-config-sync.test.ts

@@ -0,0 +1,84 @@
+import { copyFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { expect, test } from 'bun:test'
+import { synchronizePortable } from './portable-catalog.js'
+import { withPortableFixture } from '../test-support/portable-fixture.js'
+
+test('rebuilds and reports source metadata changes when source commits stay fixed', () =>
+  withPortableFixture(async (input, root) => {
+    const first = await synchronizePortable(input)
+    const old = input.sources[0]!
+    await copyFile(
+      join(root, 'fixtures/source/marketplace.json'),
+      join(root, 'fixtures/source/alternate.json')
+    )
+    const cases = [
+      { ...old, displayName: 'Renamed source' },
+      { ...old, defaultBranch: 'stable' },
+      { ...old, manifestPath: 'alternate.json' },
+      { ...old, marketplaceDialect: 'openai' as const },
+    ]
+    for (const source of cases) {
+      const result = await synchronizePortable({
+        ...input,
+        sources: [source],
+        existingLock: first.lock!,
+        existingCatalog: first.catalog!,
+      })
+      expect(result.changed).toBe(true)
+      expect(result.changeReport.changedSources).toContain(source.sourceId)
+      expect(result.catalog?.sources[0]?.displayName).toBe(source.displayName)
+      expect(result.lock?.sources[0]?.defaultBranch).toBe(source.defaultBranch)
+      expect(result.lock?.sources[0]?.manifestPath).toBe(source.manifestPath)
+      expect(result.lock?.sources[0]?.marketplaceDialect).toBe(source.marketplaceDialect)
+      const repeated = await synchronizePortable({
+        ...input,
+        sources: [source],
+        existingLock: result.lock!,
+        existingCatalog: result.catalog!,
+      })
+      expect(repeated.changed).toBe(false)
+    }
+    const equivalent = await synchronizePortable({
+      ...input,
+      sources: [{ ...old, repositoryUrl: `${old.repositoryUrl}.git` }],
+      existingLock: first.lock!,
+      existingCatalog: first.catalog!,
+    })
+    expect(equivalent.changed).toBe(false)
+  }))
+
+test('rebuilds if the marketplace repository changes while external plugin pins stay equal', () =>
+  withPortableFixture(async (input, root) => {
+    const { writeFile } = await import('node:fs/promises')
+    await writeFile(
+      join(root, 'fixtures/source/marketplace.json'),
+      JSON.stringify({
+        plugins: [
+          { name: 'remote', source: { source: 'git', url: 'https://github.com/example/external' } },
+        ],
+      })
+    )
+    const snapshotLoader = {
+      load: async () => ({
+        files: new Map([['plugin.json', new TextEncoder().encode('{"name":"Remote"}')]]),
+        symlinks: [],
+      }),
+    }
+    const options = { ...input, snapshotLoader }
+    const first = await synchronizePortable(options)
+    const source = {
+      ...input.sources[0]!,
+      repositoryUrl: 'https://github.com/example/moved-marketplace',
+    }
+    const result = await synchronizePortable({
+      ...options,
+      sources: [source],
+      existingLock: first.lock!,
+    })
+    expect(result.changed).toBe(true)
+    expect(result.lock?.sources[0]?.repositoryUrl).toBe(source.repositoryUrl)
+    expect(result.catalog?.sources[0]?.repositoryUrl).toBe(source.repositoryUrl)
+    expect(result.changeReport.changedSources).toEqual([source.sourceId])
+    expect(result.lock?.sources[0]?.pluginPins).toEqual(first.lock?.sources[0]?.pluginPins)
+  }))

package/src/source-digest.test.ts

@@ -1,4 +1,4 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { spawnSync } from 'node:child_process'
 import { pathToFileURL } from 'node:url'
@@ -11,20 +11,17 @@ test('source digests agree across consumer locales and equivalent Unicode path o
   try {
     const entry = join(directory, 'entry.ts')
     const output = join(directory, 'consumer.mjs')
-    await writeFile(
-      entry,
-      `export { bytesDigest } from '../index.ts'\nexport { sourceDigest } from '../agent-plugins-catalog.ts'\n`
-    )
+    await writeFile(entry, `export { sourceDigest } from '../digest.ts'\n`)
     const build = await Bun.build({ entrypoints: [entry], target: 'node', packages: 'external' })
     expect(build.success).toBe(true)
     await Bun.write(output, build.outputs[0]!)
     const script = `
-      import { bytesDigest, sourceDigest } from ${JSON.stringify(pathToFileURL(output).href)};
+      import { sourceDigest } from ${JSON.stringify(pathToFileURL(output).href)};
       const paths = ['z.txt', 'ä.txt', 'é.txt', 'e\\u0301.txt'];
       const entries = paths.map((path) => [path, new TextEncoder().encode(path)]);
       const forward = new Map(entries), reverse = new Map([...entries].reverse());
       console.log(JSON.stringify([
-        bytesDigest(forward), bytesDigest(reverse), sourceDigest(forward), sourceDigest(reverse)
+        sourceDigest(forward), sourceDigest(reverse)
       ]));
     `
     const results = ['en_US.UTF-8', 'sv_SE.UTF-8'].map((locale) => {
@@ -34,7 +31,6 @@ test('source digests agree across consumer locales and equivalent Unicode path o
       })
       if (result.error) throw result.error
       if (result.status !== 0) throw new Error(result.stderr)
-      expect(result.status).toBe(0)
       return JSON.parse(result.stdout) as string[]
     })
     expect(new Set(results.flat()).size).toBe(1)
@@ -42,3 +38,60 @@ test('source digests agree across consumer locales and equivalent Unicode path o
     await rm(directory, { recursive: true, force: true })
   }
 })
+
+test('source lock identity is independent of the consumer locale', async () => {
+  const directory = await mkdtemp(join(import.meta.dirname, '.source-lock-'))
+  try {
+    const source = join(directory, 'fixture', 'source')
+    await mkdir(source, { recursive: true })
+    await writeFile(
+      join(source, 'marketplace.json'),
+      JSON.stringify({
+        plugins: [
+          { name: 'a-plugin', source: './a' },
+          { name: 'ä-plugin', source: './u' },
+          { name: 'z-plugin', source: './z' },
+        ],
+      })
+    )
+    const entry = join(directory, 'entry.ts')
+    const output = join(directory, 'consumer.mjs')
+    await writeFile(entry, "export { synchronize } from '../index.ts'\n")
+    const build = await Bun.build({ entrypoints: [entry], target: 'node', packages: 'external' })
+    expect(build.success).toBe(true)
+    await Bun.write(output, build.outputs[0]!)
+    const script = `
+      import { synchronize } from ${JSON.stringify(pathToFileURL(output).href)};
+      const result = await synchronize({
+        mode: 'offline', fixtureRoot: ${JSON.stringify(join(directory, 'fixture'))},
+        sources: [{sourceId:'test-source',displayName:'Test',marketplaceDialect:'claude',
+          repositoryUrl:'https://github.com/example/plugins',manifestPath:'marketplace.json',
+          defaultBranch:'main',trustClassification:'official',fixturePath:'source',
+          fixtureCommitSha:'a'.repeat(40)}],
+        categoryMap:{aliases:{},fallback:'other'},productAliases:{aliases:{}},
+        policy:{allowedRepositoryProtocols:['https:'],allowedRepositoryHosts:['github.com'],
+          maxFilesPerPlugin:100,maxBytesPerPlugin:100000,maxFileBytes:20000,
+          maxMarketplacePlugins:100,denyExecutableLifecycleScripts:true,
+          publishRequiresCompleteContent:false,sensitiveCapabilityTypes:[]},metadataOnly:true
+      });
+      console.log(JSON.stringify({lockId:result.lock.lockId,pins:result.lock.sources[0].pluginPins}));
+    `
+    const results = ['en_US.UTF-8', 'sv_SE.UTF-8'].map((locale) => {
+      const result = spawnSync('node', ['--input-type=module', '-e', script], {
+        encoding: 'utf8',
+        env: { ...process.env, LANG: locale, LC_ALL: locale },
+      })
+      if (result.error) throw result.error
+      if (result.status !== 0) throw new Error(result.stderr)
+      return JSON.parse(result.stdout) as { lockId: string; pins: { pluginName: string }[] }
+    })
+    expect(results[0]).toEqual(results[1])
+    expect(results[0]!.pins.map((pin) => pin.pluginName)).toEqual([
+      'a-plugin',
+      'z-plugin',
+      'ä-plugin',
+    ])
+  } finally {
+    await rm(directory, { recursive: true, force: true })
+  }
+})