add endpoints

packages/@inlay/render/src/index.ts

···
 export type { Main as ComponentRecord } from "../../../../generated/at/inlay/component.defs.js";
 export type { CachePolicy } from "../../../../generated/at/inlay/defs.defs.js";
 
+export type EndpointRecord = {
+  did: string;
+  createdAt: string;
+};
+
 export interface Resolver {
   fetchRecord(uri: AtUriString): Promise<unknown | null>;
   xrpc(params: {
···
     personalized?: boolean;
   }): Promise<unknown>;
   resolveLexicon(nsid: string): Promise<unknown | null>;
+  /**
+   * Find the first DID (in order) that has a record in the given collection
+   * with the given rkey. Used for component and endpoint resolution.
+   */
+  resolve(
+    dids: DidString[],
+    collection: string,
+    rkey: string
+  ): Promise<{ did: DidString; uri: AtUriString; record: unknown } | null>;
 }
 
 export type RenderOptions = {
···
   componentUri: string;
   component: ComponentRecord;
 }> {
-  const uris = importStack.map(
-    (did) => `at://${did}/at.inlay.component/${nsid}` as AtUriString
+  const result = await resolver.resolve(
+    importStack,
+    "at.inlay.component",
+    nsid
   );
-  const promises = uris.map((uri) => resolver.fetchRecord(uri));
+  if (!result) throw new Error(`Unresolved type: ${nsid}`);
+  return {
+    componentUri: result.uri,
+    component: result.record as ComponentRecord,
+  };
+}
 
-  for (let i = 0; i < importStack.length; i++) {
-    const component = (await promises[i]) as ComponentRecord | null;
-    if (!component) continue;
-    return { componentUri: uris[i], component };
-  }
-
-  throw new Error(`Unresolved type: ${nsid}`);
+/**
+ * Resolve an endpoint NSID through the import stack.
+ * Walks DIDs looking for `at.inlay.endpoint/{nsid}` records.
+ * Returns the service DID from the first matching record.
+ */
+export async function resolveEndpoint(
+  nsid: string,
+  imports: DidString[],
+  resolver: Resolver
+): Promise<{ did: string; endpointUri: string }> {
+  const result = await resolver.resolve(imports, "at.inlay.endpoint", nsid);
+  if (!result) throw new Error(`Unresolved endpoint: ${nsid}`);
+  const record = result.record as EndpointRecord;
+  if (!record.did) throw new Error(`Endpoint record missing did: ${nsid}`);
+  return { did: record.did, endpointUri: result.uri };
 }
 
 async function renderTemplate(

packages/@inlay/render/test/render.test.ts

···
 import {
   render,
   createContext,
+  resolveEndpoint,
   MissingError,
   type ComponentRecord,
   type CachePolicy,
···
     },
     resolveLexicon: async (nsid) => {
       log.push(`lexicon ${nsid}`);
+      return null;
+    },
+    async resolve(dids, collection, rkey) {
+      const uris = dids.map(
+        (did) => `at://${did}/${collection}/${rkey}` as AtUriString
+      );
+      const promises = uris.map((uri) => resolver.fetchRecord(uri));
+      for (let i = 0; i < dids.length; i++) {
+        const record = await promises[i];
+        if (record) return { did: dids[i], uri: uris[i], record };
+      }
       return null;
     },
   };
···
     });
 
     // Greeting's resolver fails — error should bubble with full owner chain.
+    const wrappedFetch = ((original) => async (uri: AtUriString) => {
+      const result = await original(uri);
+      if (result && uri === `at://${APP_DID}/at.inlay.component/${Greeting}`) {
+        // Return a component whose template references a missing type.
+        return {
+          ...result,
+          body: {
+            $type: "at.inlay.component#bodyTemplate",
+            node: serializeTree($("test.app.DoesNotExist", {})),
+          },
+        };
+      }
+      return result;
+    })(options.resolver.fetchRecord);
+
     const output = await renderToCompletion(
       $(Page, {}),
       {
         ...options,
         resolver: {
           ...options.resolver,
-          fetchRecord: ((original) => async (uri: AtUriString) => {
-            const result = await original(uri);
-            if (
-              result &&
-              uri === `at://${APP_DID}/at.inlay.component/${Greeting}`
-            ) {
-              // Return a component whose template references a missing type.
-              return {
-                ...result,
-                body: {
-                  $type: "at.inlay.component#bodyTemplate",
-                  node: serializeTree($("test.app.DoesNotExist", {})),
-                },
-              };
+          fetchRecord: wrappedFetch,
+          async resolve(dids, collection, rkey) {
+            const uris = dids.map(
+              (did) => `at://${did}/${collection}/${rkey}` as AtUriString
+            );
+            const promises = uris.map((uri) => wrappedFetch(uri));
+            for (let i = 0; i < dids.length; i++) {
+              const record = await promises[i];
+              if (record) return { did: dids[i], uri: uris[i], record };
             }
-            return result;
-          })(options.resolver.fetchRecord),
-          xrpc: options.resolver.xrpc,
-          resolveLexicon: options.resolver.resolveLexicon,
+            return null;
+          },
         },
       },
       createContext(pageComponent, `at://${APP_DID}/at.inlay.component/${Page}`)
···
           throw new Error("unreachable");
         },
         resolveLexicon: async () => null,
+        resolve: async () => {
+          throw new Error("network down");
+        },
       },
     };
 
···
     assert.equal(capturedPersonalized, false);
   });
 });
+
+// ============================================================================
+// Endpoint resolution
+// ============================================================================
+
+describe("endpoint resolution", () => {
+  const QUERY_NSID = "test.app.getItems";
+  const ENDPOINT_DID = "did:plc:endpoint-author";
+  const SERVICE_DID_EP = "did:web:my-val.val.run";
+
+  it("resolves endpoint through import stack", async () => {
+    const { options } = testResolver({
+      [`at://${ENDPOINT_DID}/at.inlay.endpoint/${QUERY_NSID}`]: {
+        did: SERVICE_DID_EP,
+        createdAt: "2025-01-01T00:00:00Z",
+      },
+    } as any);
+
+    const result = await resolveEndpoint(
+      QUERY_NSID,
+      [ENDPOINT_DID as any],
+      options.resolver
+    );
+    assert.equal(result.did, SERVICE_DID_EP);
+    assert.equal(
+      result.endpointUri,
+      `at://${ENDPOINT_DID}/at.inlay.endpoint/${QUERY_NSID}`
+    );
+  });
+
+  it("first DID in import stack wins", async () => {
+    const DID_A = "did:plc:a" as any;
+    const DID_B = "did:plc:b" as any;
+
+    const { options } = testResolver({
+      [`at://${DID_A}/at.inlay.endpoint/${QUERY_NSID}`]: {
+        did: "did:web:val-a.val.run",
+        createdAt: "2025-01-01T00:00:00Z",
+      },
+      [`at://${DID_B}/at.inlay.endpoint/${QUERY_NSID}`]: {
+        did: "did:web:val-b.val.run",
+        createdAt: "2025-01-01T00:00:00Z",
+      },
+    } as any);
+
+    const result = await resolveEndpoint(
+      QUERY_NSID,
+      [DID_A, DID_B],
+      options.resolver
+    );
+    assert.equal(result.did, "did:web:val-a.val.run");
+  });
+
+  it("falls through to later DIDs", async () => {
+    const DID_A = "did:plc:a" as any;
+    const DID_B = "did:plc:b" as any;
+
+    const { options } = testResolver({
+      [`at://${DID_B}/at.inlay.endpoint/${QUERY_NSID}`]: {
+        did: "did:web:val-b.val.run",
+        createdAt: "2025-01-01T00:00:00Z",
+      },
+    } as any);
+
+    const result = await resolveEndpoint(
+      QUERY_NSID,
+      [DID_A, DID_B],
+      options.resolver
+    );
+    assert.equal(result.did, "did:web:val-b.val.run");
+  });
+
+  it("throws when no DID has the endpoint", async () => {
+    const { options } = testResolver({} as any);
+
+    await assert.rejects(
+      () =>
+        resolveEndpoint(
+          QUERY_NSID,
+          ["did:plc:nobody" as any],
+          options.resolver
+        ),
+      { message: `Unresolved endpoint: ${QUERY_NSID}` }
+    );
+  });
+});

proto/src/index.tsx

···
   type JSXElement,
 } from "./render.tsx";
 import { deserializeTree, $ } from "@inlay/core";
+import { resolveEndpoint } from "@inlay/render";
 import { setQueryString } from "./primitives.tsx";
 import { resolveDidToService } from "./resolve.ts";
 import {
···
 
 app.get("/", (c) =>
   c.redirect(
-    "/at/did:plc:ragtjsm2j2vknwkz3zp4oxrd/app.bsky.actor.profile/self?componentUri=at%3A%2F%2Fdid%3Aplc%3Afpruhuo22xkm5o7ttr2ktxdo%2Fat.inlay.component%2Fmov.danabra.ProfilePage&layout=page"
+    "/at/did:plc:ragtjsm2j2vknwkz3zp4oxrd/app.bsky.actor.profile/self?componentUri=at%3A%2F%2Fdid%3Aplc%3Afpruhuo22xkm5o7ttr2ktxdo%2Fat.inlay.component%2Fmov.danabra.Profile&layout=page"
   )
 );
 
···
 // --- HTMX list pagination endpoint ---
 app.get("/htmx/list", async (c) => {
   const query = c.req.query("query");
-  const did = c.req.query("did");
   const cursor = c.req.query("cursor");
   const inputStr = c.req.query("input");
   const importsStr = c.req.query("imports");
 
-  if (!query || !did || !cursor) {
+  if (!query || !cursor) {
     return c.html(<div class="error">Missing params</div>);
   }
 
···
 
     const ctx: RenderContext = { imports };
 
-    const serviceUrl = await resolveDidToService(did, "#inlay");
+    const endpoint = await resolveEndpoint(query, imports, sharedResolver);
+    const serviceUrl = await resolveDidToService(endpoint.did, "#inlay");
     const params = new URLSearchParams();
     for (const [k, v] of Object.entries({ ...input, cursor })) {
       if (v != null) params.set(k, String(v));
···
 
     const importsParam = encodeURIComponent(JSON.stringify(imports));
     const sentinelUrl = page.cursor
-      ? `/htmx/list?query=${encodeURIComponent(query)}&did=${encodeURIComponent(did)}&cursor=${encodeURIComponent(page.cursor)}&input=${encodeURIComponent(JSON.stringify(input))}&imports=${importsParam}`
+      ? `/htmx/list?query=${encodeURIComponent(query)}&cursor=${encodeURIComponent(page.cursor)}&input=${encodeURIComponent(JSON.stringify(input))}&imports=${importsParam}`
       : null;
 
     c.header("Cache-Control", "private, max-age=120");

proto/src/primitives.tsx

···
 import { Suspense } from "hono/jsx/streaming";
 import { ErrorBoundary } from "hono/jsx";
 import type { RenderContext } from "@inlay/render";
-import { MissingError } from "@inlay/render";
+import { MissingError, resolveEndpoint } from "@inlay/render";
 import { resolveDidToService } from "./resolve.ts";
 import { isValidElement, deserializeTree } from "@inlay/core";
 import "./types.ts";
···
 // Hono's JSX.Element — what all JSX expressions produce
 type JSXElement = HtmlEscapedString | Promise<HtmlEscapedString>;
 
-// renderNode is injected to avoid circular deps
+// renderNode and resolver are injected to avoid circular deps
 let _renderNode: (node: unknown, ctx: RenderContext) => Promise<JSXElement>;
+let _resolver: import("@inlay/render").Resolver;
 let _qs: string = "";
 
 export function setRenderNode(
   fn: (node: unknown, ctx: RenderContext) => Promise<JSXElement>
 ) {
   _renderNode = fn;
+}
+
+export function setResolver(resolver: import("@inlay/render").Resolver) {
+  _resolver = resolver;
 }
 
 export function setQueryString(qs: string) {
···
 async function List({ ctx, props }: PrimitiveProps) {
   const p = props as {
     query: string;
-    did: string;
     input?: Record<string, unknown>;
   };
-  if (!p.did || !p.query) {
-    return <div class="error">List: missing did or query</div>;
+  if (!p.query) {
+    return <div class="error">List: missing query</div>;
   }
 
-  const serviceUrl = await resolveDidToService(p.did, "#inlay");
+  const endpoint = await resolveEndpoint(p.query, ctx.imports, _resolver);
+  const serviceUrl = await resolveDidToService(endpoint.did, "#inlay");
   const params = new URLSearchParams();
   if (p.input) {
     for (const [k, v] of Object.entries(p.input)) {
···
   }
 
   const importsParam = encodeURIComponent(JSON.stringify(ctx.imports));
-  const sentinelUrl = `/htmx/list?query=${encodeURIComponent(p.query)}&did=${encodeURIComponent(p.did)}&cursor=${encodeURIComponent(page.cursor ?? "")}&input=${encodeURIComponent(JSON.stringify(p.input ?? {}))}&imports=${importsParam}`;
+  const sentinelUrl = `/htmx/list?query=${encodeURIComponent(p.query)}&cursor=${encodeURIComponent(page.cursor ?? "")}&input=${encodeURIComponent(JSON.stringify(p.input ?? {}))}&imports=${importsParam}`;
 
   return (
     <>

proto/src/render.tsx

···
   type RenderOptions,
 } from "@inlay/render";
 import { isValidElement } from "@inlay/core";
-import { componentMap, setRenderNode } from "./primitives.tsx";
+import { componentMap, setRenderNode, setResolver } from "./primitives.tsx";
 import "./types.ts";
 
 // Hono's JSX.Element type — what all JSX expressions return
···
 
 export function initRender(options: RenderOptions) {
   setRenderNode((node, ctx) => renderNode(node, ctx, options));
+  setResolver(options.resolver);
 }

proto/src/resolver.ts

···
   const res = await fetch(
     `${SLINGSHOT}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(parsed.host)}&collection=${encodeURIComponent(parsed.collection)}&rkey=${encodeURIComponent(parsed.rkey)}`
   );
-  if (!res.ok) return null;
+  if (!res.ok) {
+    // Cache misses to avoid hammering PDS for records that don't exist.
+    // Uses shorter TTL than hits — the record might be created later.
+    await cacheSet(key, null, { life: "minutes" });
+    return null;
+  }
 
   const data = await res.json();
   const value = data.value as Record<string, unknown>;
···
   return {
     async fetchRecord(uri) {
       return fetchRecordFromPds(uri);
+    },
+
+    async resolve(dids, collection, rkey) {
+      const uris = dids.map((did) => `at://${did}/${collection}/${rkey}`);
+      const promises = uris.map((uri) => fetchRecordFromPds(uri));
+      for (let i = 0; i < dids.length; i++) {
+        const record = await promises[i];
+        if (record) return { did: dids[i], uri: uris[i] as any, record };
+      }
+      return null;
     },
 
     async xrpc(params) {