@atproto/bsky 0.0.233 → 0.0.235

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/bsky",
-  "version": "0.0.233",
+  "version": "0.0.235",
   "license": "MIT",
   "description": "Reference implementation of app.bsky App View (Bluesky API)",
   "keywords": [
@@ -50,12 +50,12 @@
     "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.6",
     "@atproto/common": "^0.6.1",
     "@atproto/crypto": "^0.5.0",
-    "@atproto/did": "^0.4.0",
+    "@atproto/did": "^0.5.0",
     "@atproto/identity": "^0.5.0",
-    "@atproto/lex": "^0.1.2",
+    "@atproto/lex": "^0.1.3",
     "@atproto/repo": "^0.10.0",
     "@atproto/sync": "^0.3.1",
     "@atproto/syntax": "^0.6.1",
@@ -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.1"
   },
   "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/external.ts

@@ -1,6 +1,7 @@
 import { AtUriString } from '@atproto/syntax'
 import { DataPlaneClient } from '../data-plane/client/index.js'
 import { site } from '../lexicons/index.js'
+import { hydrationLogger } from '../logger.js'
 import {
   GetSiteStandardRecordsByRefResponse,
   GetSiteStandardRecordsByURIResponse,
@@ -162,6 +163,14 @@ export const getSiteStandardRecordsFromHydrationMapsByRefs = (
   // (or tampered with), so reject the whole pairing.
   if (document && publication) {
     if (document.info.record.site !== publication.ref.uri) {
+      hydrationLogger.warn(
+        {
+          documentUri: document.ref.uri,
+          documentSite: document.info.record.site,
+          publicationUri: publication.ref.uri,
+        },
+        'site.standard byRefs lookup failed: doc.site does not match hydrated publication.uri',
+      )
       return { document: undefined, publication: undefined }
     }
   }
@@ -172,6 +181,10 @@ export const getSiteStandardRecordsFromHydrationMapsByRefs = (
   if (document && !publication) {
     const site = document.info.record.site
     if (site && site.startsWith('at://')) {
+      hydrationLogger.warn(
+        { documentUri: document.ref.uri, documentSite: site },
+        'site.standard byRefs lookup failed: document.site is AT URI but no matching publication was hydrated',
+      )
       return { document: undefined, publication: undefined }
     }
   }
@@ -234,6 +247,10 @@ export const getSiteStandardRecordsFromHydrationMapsByDocumentUri = (
         }
       }
       if (!publication) {
+        hydrationLogger.warn(
+          { documentUri: document.ref.uri, documentSite: site },
+          'site.standard byDocumentUri lookup failed: document.site is AT URI but no matching publication was hydrated',
+        )
         return { document: undefined, publication: undefined }
       }
     }

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

@@ -101,6 +101,13 @@ describe(validateStandardSiteForUrl, () => {
         validateStandardSiteForUrl(undefined, pub, 'https://other.com'),
       ).toBe(false)
     })
+
+    it('accepts when assumedUrl has a trailing slash and publication.url does not', () => {
+      const pub = makePub({ url: 'https://atproto.com/blog' })
+      expect(
+        validateStandardSiteForUrl(undefined, pub, 'https://atproto.com/blog/'),
+      ).toBe(true)
+    })
   })
 
   describe('neither', () => {
@@ -158,29 +165,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

@@ -1,4 +1,4 @@
-import { HOUR, MINUTE, mapDefined } from '@atproto/common'
+import { HOUR, MINUTE, dedupeStrs, mapDefined } from '@atproto/common'
 import {
   $Typed,
   Un$Typed,
@@ -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,
@@ -2246,6 +2247,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,
+        },
+        'site.standard URL validation failed',
+      )
       return undefined
     }
 
@@ -2314,6 +2322,21 @@ export class Views {
       overlay.source = this.externalEmbedSource(publication)
     }
 
+    // Profiles of the owners of the records backing this embed. 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 uniqueDids = dedupeStrs(
+      mapDefined([document?.ref.uri, publication?.ref.uri], (uri) =>
+        uri ? uriToDid(uri) : undefined,
+      ) as DidString[],
+    )
+    const associatedProfiles = mapDefined(uniqueDids, (did) =>
+      this.profileBasic(did, state),
+    ) as ProfileViewBasic[]
+    if (associatedProfiles.length)
+      overlay.associatedProfiles = associatedProfiles
+
     return overlay
   }
 

package/tests/views/profile.test.ts

@@ -724,18 +724,14 @@ describe('pds profile views', () => {
   })
 
   it('filters out Go zero-value dates from dataplane', async () => {
-    // Spy on the dataplane getActors method
-    const getActorsSpy = vi.spyOn(network.bsky.ctx.dataplane, 'getActors')
+    using getActorsSpy = vi.spyOn(network.bsky.ctx.dataplane, 'getActors')
 
-    // Call the original implementation but modify the result
     getActorsSpy.mockImplementationOnce(async (req) => {
-      // Call the real method
       const result = await network.bsky.ctx.dataplane.getActors(req)
 
-      // Modify the result to inject a Go zero-value date
+      // Inject a Go zero-value date (0001-01-01 00:00:00 UTC)
       if (result.actors.length > 0 && result.actors[0]) {
         const actor = result.actors[0]
-        // Create a Timestamp with Go zero-value (0001-01-01 00:00:00 UTC)
         const goZeroDate = new Date(-62135596800000)
         actor.createdAt = Timestamp.fromDate(goZeroDate)
       }
@@ -750,11 +746,8 @@ describe('pds profile views', () => {
       },
     )
 
-    // The createdAt should be undefined because the hydration layer filters it out
+    // The hydration layer filters Go zero-values out
     expect(data.createdAt).toBeUndefined()
-
-    // Clean up
-    getActorsSpy.mockRestore()
   })
 
   async function updateProfile(did: string, record: Record<string, unknown>) {