@atproto/bsky 0.0.233 → 0.0.234

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/bsky",
-  "version": "0.0.233",
+  "version": "0.0.234",
   "license": "MIT",
   "description": "Reference implementation of app.bsky App View (Bluesky API)",
   "keywords": [
@@ -50,7 +50,7 @@
     "zod": "3.23.8",
     "@atproto-labs/fetch-node": "^0.3.0",
     "@atproto-labs/xrpc-utils": "^0.1.0",
-    "@atproto/api": "^0.20.3",
+    "@atproto/api": "^0.20.5",
     "@atproto/common": "^0.6.1",
     "@atproto/crypto": "^0.5.0",
     "@atproto/did": "^0.4.0",
@@ -74,7 +74,7 @@
     "ts-node": "^10.8.2",
     "typescript": "^6.0.3",
     "vitest": "^4.0.16",
-    "@atproto/pds": "^0.4.225"
+    "@atproto/pds": "^0.5.0"
   },
   "type": "module",
   "exports": {

package/src/api/app/bsky/embed/getEmbedExternalView.ts

@@ -61,8 +61,9 @@ const hydration = async (
 const presentation = (
   inputs: PresentationFnInput<Context, Params, Skeleton>,
 ): Output => {
-  const documents = inputs.hydration.siteStandardDocuments
-  const publications = inputs.hydration.siteStandardPublications
+  const { hydration } = inputs
+  const documents = hydration.siteStandardDocuments
+  const publications = hydration.siteStandardPublications
   // Dispatch by record type. Today site.standard is the only kind we know
   // how to render; future record types get their own branch.
   if (
@@ -93,7 +94,8 @@ const standardSitePresentation = (
   // Emit response refs/records only for the records we actually selected.
   // Anything else (e.g. extra publications the dataplane returned) is
   // intentionally excluded so the strongRefs Cardy writes onto the post
-  // match the view we built.
+  // match the view we built. Profiles are emitted in the same order as
+  // refs (one per slot) so consumers can match by index.
   const associatedRefs: StrongRef[] = []
   const associatedRecords: LexMap[] = []
   for (const slot of [document, publication]) {

package/src/hydration/hydrator.ts

@@ -612,6 +612,15 @@ export class Hydrator {
     const siteStandardLabelSubjects = dedupeStrs(
       siteStandardRefs.map((ref) => ref.uri),
     )
+    // Site-standard record owners need profile basics so we can populate
+    // `associatedProfiles` on the external embed view. Include them in the
+    // post-author profile fetch below; any DIDs surfaced later by the
+    // dataplane are picked up by the top-up after the parallel batch.
+    const ssRefDids = siteStandardRefs.map((ref) => uriToDid(ref.uri))
+    const knownProfileDids = dedupeStrs([
+      ...allPostUris.map(didFromUri),
+      ...ssRefDids,
+    ])
 
     const [
       postAggs,
@@ -638,7 +647,7 @@ export class Hydrator {
         ctx.labelers,
       ),
       this.hydratePostBlocks(posts, ctx),
-      this.hydrateProfiles(allPostUris.map(didFromUri), ctx),
+      this.hydrateProfiles(knownProfileDids, ctx),
       this.hydrateLists([...nestedListUris, ...threadgateListUris], ctx),
       this.hydrateFeedGens(nestedFeedGenUris, ctx),
       this.hydrateLabelers(nestedLabelerDids, ctx),
@@ -657,9 +666,28 @@ export class Hydrator {
         labels,
       )
     }
+
+    // Defensive top-up: in the unlikely case the dataplane returned a
+    // publication owned by a DID not present in the post-author or
+    // pinned-ref sets, fetch its profile serially and fold it in.
+    const knownProfileDidsSet = new Set(knownProfileDids)
+    const extraSsDids: DidString[] = []
+    for (const key of siteStandardPublications.keys()) {
+      const did = uriToDid(parseSiteStandardRecordKey(key).uri)
+      if (!knownProfileDidsSet.has(did)) {
+        knownProfileDidsSet.add(did)
+        extraSsDids.push(did)
+      }
+    }
+    const mergedProfileState = extraSsDids.length
+      ? mergeStates(
+          profileState,
+          await this.hydrateProfilesBasic(extraSsDids, ctx),
+        )
+      : profileState
     // combine all hydration state
     return mergeManyStates(
-      profileState,
+      mergedProfileState,
       listState,
       feedGenState,
       labelerState,
@@ -810,20 +838,40 @@ export class Hydrator {
       ),
     ) as AtUriString[]
     if (!ssUris.length) return { ctx }
+    const dids = dedupeStrs(ssUris.map((uri) => uriToDid(uri)))
 
-    const [{ documents, publications }, labels] = await Promise.all([
+    const [{ documents, publications }, labels, profiles] = await Promise.all([
       this.external.getSiteStandardRecordsByURI(ssUris, ctx.includeTakedowns),
       this.label.getLabelsForSubjects(ssUris, ctx.labelers),
+      this.hydrateProfilesBasic(dids, ctx),
     ])
     if (!ctx.includeTakedowns) {
       actionSiteStandardTakedownLabels(documents, publications, labels)
     }
-    return {
+    // Edge case: a document's `site` may resolve to a publication owned by a
+    // different repo than any of the input URIs (the dataplane returns it
+    // even though it wasn't requested directly). Top up profile coverage for
+    // any such DIDs with a serial second hydration so `associatedProfiles`
+    // is complete.
+    const knownDids = new Set<string>(dids)
+    const extraDids: DidString[] = []
+    for (const key of publications.keys()) {
+      const did = uriToDid(parseSiteStandardRecordKey(key).uri)
+      if (!knownDids.has(did)) {
+        knownDids.add(did)
+        extraDids.push(did)
+      }
+    }
+    const profilesState = extraDids.length
+      ? mergeStates(profiles, await this.hydrateProfilesBasic(extraDids, ctx))
+      : profiles
+
+    return mergeStates(profilesState, {
       ctx,
       labels,
       siteStandardDocuments: documents,
       siteStandardPublications: publications,
-    }
+    })
   }
 
   // app.bsky.feed.defs#threadViewPost

package/src/logger.ts

@@ -19,6 +19,8 @@ export const dataplaneLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:dp')
 export const ageAssuranceLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:aa')
+export const viewsLogger: ReturnType<typeof subsystemLogger> =
+  subsystemLogger('bsky:views')
 export const httpLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky')
 

package/src/util/standard-site.test.ts

@@ -158,29 +158,114 @@ describe(validateStandardSiteForUrl, () => {
     }
   })
 
-  describe('publication.url variants', () => {
-    it('accepts when publication.url has trailing slash', () => {
-      const doc = makeDoc({ site: pubUri, path: '/posts/hello' })
-      const pub = makePub({ url: 'https://example.com/' })
-      expect(
-        validateStandardSiteForUrl(doc, pub, 'https://example.com/posts/hello'),
-      ).toBe(true)
-    })
-
-    it('accepts when document.path lacks a leading slash', () => {
-      const doc = makeDoc({ site: pubUri, path: 'posts/hello' })
-      const pub = makePub({ url: 'https://example.com/' })
-      expect(
-        validateStandardSiteForUrl(doc, pub, 'https://example.com/posts/hello'),
-      ).toBe(true)
-    })
-
-    it('handles publication.url with sub-path and document.path joining onto it', () => {
-      const doc = makeDoc({ site: pubUri, path: 'hello' })
-      const pub = makePub({ url: 'https://example.com/blog/' })
-      expect(
-        validateStandardSiteForUrl(doc, pub, 'https://example.com/blog/hello'),
-      ).toBe(true)
-    })
+  describe('path joining (root domain × subpath × slash placement)', () => {
+    // Real-world example that originally broke:
+    //   pub.url:  'https://atproto.com/blog'
+    //   doc.path: '/indexing-standard-site'
+    //   expected: 'https://atproto.com/blog/indexing-standard-site'
+    // `new URL('/indexing-standard-site', 'https://atproto.com/blog')` would
+    // resolve to 'https://atproto.com/indexing-standard-site' (the leading
+    // slash on path swallows the base's pathname under WHATWG semantics) —
+    // we want path-append, not relative resolution.
+    for (const { note, baseUrl, path, assumedUrl, expected } of [
+      // Root-domain base, all four slash combinations.
+      {
+        note: 'root base, base/, path/',
+        baseUrl: 'https://example.com/',
+        path: '/posts/hello',
+        assumedUrl: 'https://example.com/posts/hello',
+        expected: true,
+      },
+      {
+        note: 'root base, base/, path-no-slash',
+        baseUrl: 'https://example.com/',
+        path: 'posts/hello',
+        assumedUrl: 'https://example.com/posts/hello',
+        expected: true,
+      },
+      {
+        note: 'root base, base-no-slash, path/',
+        baseUrl: 'https://example.com',
+        path: '/posts/hello',
+        assumedUrl: 'https://example.com/posts/hello',
+        expected: true,
+      },
+      {
+        note: 'root base, base-no-slash, path-no-slash',
+        baseUrl: 'https://example.com',
+        path: 'posts/hello',
+        assumedUrl: 'https://example.com/posts/hello',
+        expected: true,
+      },
+      // Subpath base, all four slash combinations (the regression case).
+      {
+        note: 'subpath base, base/, path/',
+        baseUrl: 'https://atproto.com/blog/',
+        path: '/indexing-standard-site',
+        assumedUrl: 'https://atproto.com/blog/indexing-standard-site',
+        expected: true,
+      },
+      {
+        note: 'subpath base, base/, path-no-slash',
+        baseUrl: 'https://atproto.com/blog/',
+        path: 'indexing-standard-site',
+        assumedUrl: 'https://atproto.com/blog/indexing-standard-site',
+        expected: true,
+      },
+      {
+        note: 'subpath base, base-no-slash, path/ (regression)',
+        baseUrl: 'https://atproto.com/blog',
+        path: '/indexing-standard-site',
+        assumedUrl: 'https://atproto.com/blog/indexing-standard-site',
+        expected: true,
+      },
+      {
+        note: 'subpath base, base-no-slash, path-no-slash',
+        baseUrl: 'https://atproto.com/blog',
+        path: 'indexing-standard-site',
+        assumedUrl: 'https://atproto.com/blog/indexing-standard-site',
+        expected: true,
+      },
+      // Empty path: assumedUrl should equal the base.
+      {
+        note: 'empty path, root base, no trailing slash',
+        baseUrl: 'https://example.com',
+        path: undefined,
+        assumedUrl: 'https://example.com',
+        expected: true,
+      },
+      {
+        note: 'empty path, subpath base, with trailing slash',
+        baseUrl: 'https://atproto.com/blog/',
+        path: undefined,
+        assumedUrl: 'https://atproto.com/blog',
+        expected: true,
+      },
+      // Negative: subpath base with assumedUrl that lost the subpath
+      // (what `new URL`'s relative resolution would have produced).
+      {
+        note: 'rejects when assumed URL drops the subpath',
+        baseUrl: 'https://atproto.com/blog',
+        path: '/indexing-standard-site',
+        assumedUrl: 'https://atproto.com/indexing-standard-site',
+        expected: false,
+      },
+    ]) {
+      it(`doc + pub: ${note}`, () => {
+        const doc = makeDoc(
+          path === undefined ? { site: pubUri } : { site: pubUri, path },
+        )
+        const pub = makePub({ url: baseUrl })
+        expect(validateStandardSiteForUrl(doc, pub, assumedUrl)).toBe(expected)
+      })
+      it(`loose doc: ${note}`, () => {
+        const doc = makeDoc(
+          path === undefined ? { site: baseUrl } : { site: baseUrl, path },
+        )
+        expect(validateStandardSiteForUrl(doc, undefined, assumedUrl)).toBe(
+          expected,
+        )
+      })
+    }
   })
 })

package/src/util/standard-site.ts

@@ -27,10 +27,10 @@ export const parseSiteStandardRecordKey = (
  * strips a trailing slash from the path, and drops query/fragment. Returns
  * `null` when the input isn't a valid HTTP(S) URL.
  */
-const canonicalizeHttpUrl = (url: string, base?: string): string | null => {
+const canonicalizeHttpUrl = (url: string): string | null => {
   let parsed: URL
   try {
-    parsed = new URL(url, base)
+    parsed = new URL(url)
   } catch {
     return null
   }
@@ -40,11 +40,32 @@ const canonicalizeHttpUrl = (url: string, base?: string): string | null => {
 }
 
 /**
- * Confirm that the supplied SS records actually back `assumedUrl`. URL
- * comparison parses both sides via the WHATWG URL constructor (resolving
- * the document's `path` against the publication or site as a base) and
- * compares the canonical `protocol://host/path` forms — host case is
- * ignored, query/fragment are dropped, trailing slashes stripped.
+ * Append `path` to `base` with exactly one slash between, or return `base`
+ * unchanged when `path` is empty. Unlike `new URL(path, base)`, a leading
+ * slash on `path` does NOT swallow `base`'s pathname — so
+ * `joinPath('https://x.com/blog', '/foo')` is `https://x.com/blog/foo`,
+ * not `https://x.com/foo`.
+ */
+const joinPath = (base: string, path: string): string => {
+  if (!path) return base
+  const baseTrimmed = base.endsWith('/') ? base.slice(0, -1) : base
+  const pathTrimmed = path.startsWith('/') ? path.slice(1) : path
+  return `${baseTrimmed}/${pathTrimmed}`
+}
+
+/**
+ * Confirm that the supplied SS records actually back `assumedUrl`. The
+ * record-side URL is built by concatenating the publication URL (or the
+ * loose-doc site) with the document's `path` field, then both sides are
+ * canonicalized for equality: lowercase host, query/fragment dropped,
+ * trailing slash stripped.
+ *
+ * Path concatenation is `base + '/' + path` semantics — a leading `/` on
+ * `path` does NOT swallow the base's pathname (the way
+ * `new URL(path, base)` would). So
+ * `'https://atproto.com/blog' + '/indexing-standard-site'` resolves to
+ * `https://atproto.com/blog/indexing-standard-site` regardless of which
+ * side carries the slash.
  *
  * Structural validation of the doc/pub pair (matching `site` ↔ pub URI,
  * no orphan docs that claim a missing publication) happens upstream in
@@ -81,15 +102,13 @@ export const validateStandardSiteForUrl = (
 
   if (document && publication) {
     const joined = canonicalizeHttpUrl(
-      document.info.record.path ?? '',
-      publication.info.record.url,
+      joinPath(publication.info.record.url, document.info.record.path ?? ''),
     )
     return joined === canonicalAssumed
   }
   if (document) {
     const joined = canonicalizeHttpUrl(
-      document.info.record.path ?? '',
-      document.info.record.site,
+      joinPath(document.info.record.site, document.info.record.path ?? ''),
     )
     return joined === canonicalAssumed
   }

package/src/views/index.ts

@@ -28,6 +28,7 @@ import { Label } from '../hydration/label.js'
 import { RecordInfo, parseString } from '../hydration/util.js'
 import { ImageUriBuilder } from '../image/uri.js'
 import { app, site } from '../lexicons/index.js'
+import { viewsLogger } from '../logger.js'
 import { Notification } from '../proto/bsky_pb.js'
 import {
   estimateReadingTimeMinutes,
@@ -2140,6 +2141,14 @@ export class Views {
       state,
       assumedUrl: embed.external.uri,
     })
+    // Profiles of the owners of pinned `associatedRefs`. Hydrator covers
+    // these DIDs alongside post-author profiles, so misses here only
+    // happen when an actor is unavailable (suspended, deleted, etc.) —
+    // drop those rather than emit `undefined` slots.
+    const associatedProfiles = mapDefined(
+      embed.external.associatedRefs ?? [],
+      (ref) => this.profileBasic(uriToDid(ref.uri), state),
+    ) as ProfileViewBasic[]
     return app.bsky.embed.external.view.$build({
       external: {
         uri: embed.external.uri,
@@ -2154,6 +2163,9 @@ export class Views {
           : undefined,
         ...ssView,
         associatedRefs: embed.external.associatedRefs,
+        associatedProfiles: associatedProfiles.length
+          ? associatedProfiles
+          : undefined,
       },
     })
   }
@@ -2246,6 +2258,13 @@ export class Views {
     // bare embed rather than render partial / disagreeing enrichment.
     if (!document && !publication) return undefined
     if (!validateStandardSiteForUrl(document, publication, assumedUrl)) {
+      viewsLogger.warn(
+        {
+          documentUri: document?.ref.uri,
+          publicationUri: publication?.ref.uri,
+        },
+        'SS record(s) failed URL validation for external embed',
+      )
       return undefined
     }