fix(micro): address code review issues

- Validate cursor param in micro.astro; redirect to /micro on NaN input
- Add id attribute to article elements for anchor URL support
- Guard JSON.parse of syndicated_to with try/catch and type validation
- Validate D1 API response structure before accessing result rows
- Fix middleware to handle hash fragments in redirect targets without
  URL-encoding the '#' via URL.pathname setter
- Create /micro/[id] route that redirects to the correct paginated page
  with anchor, so RSS links resolve even for non-first-page posts
- Restore rss.xml.ts link to /micro/${post.id} path style
- Remove unused skippedCount variable in gen-url-manifest.ts
- Add 'M' kind coverage to code.test.ts (fromDate, getKind, getCollection)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: just-be-dev

scripts/gen-url-manifest.ts

@@ -82,7 +82,6 @@ async function processMicroCollection(
     const results = data.result[0]?.results || [];
 
     let processedCount = 0;
-    let skippedCount = 0;
     let errorCount = 0;
 
     for (const post of results) {
@@ -145,7 +144,7 @@ async function processMicroCollection(
     console.log();
     return {
       processed: processedCount,
-      skipped: skippedCount,
+      skipped: 0,
       errors: errorCount,
     };
   } catch (error) {

src/loaders/micro-loader.ts

@@ -56,17 +56,42 @@ export function microLoader(options: MicroLoaderOptions): Loader {
           throw new Error(`D1 query failed: ${JSON.stringify(data.errors)}`);
         }
 
-        const results = data.result[0]?.results || [];
+        if (!Array.isArray(data.result) || data.result.length === 0) {
+          logger.warn("D1 query returned unexpected result structure");
+          return;
+        }
+
+        const resultRows = data.result[0]?.results;
+        if (!Array.isArray(resultRows)) {
+          logger.warn("D1 query results is not an array");
+          return;
+        }
+
+        const results = resultRows as MicroPost[];
 
         // Store each post in the collection
-        for (const post of results as MicroPost[]) {
+        for (const post of results) {
+          let syndicatedTo: string[] = [];
+          if (post.syndicated_to) {
+            try {
+              const parsed = JSON.parse(post.syndicated_to);
+              if (Array.isArray(parsed) && parsed.every((s) => typeof s === "string")) {
+                syndicatedTo = parsed;
+              } else {
+                logger.warn(`Invalid syndicated_to value for post ${post.id}, defaulting to []`);
+              }
+            } catch {
+              logger.warn(`Failed to parse syndicated_to for post ${post.id}, defaulting to []`);
+            }
+          }
+
           store.set({
             id: String(post.id),
             data: {
               content: post.content,
               createdAt: new Date(post.created_at * 1000),
               updatedAt: new Date(post.updated_at * 1000),
-              syndicatedTo: post.syndicated_to ? JSON.parse(post.syndicated_to) : [],
+              syndicatedTo,
             },
           });
         }

src/middleware.ts

@@ -42,9 +42,17 @@ export const onRequest = defineMiddleware(async (context, next) => {
     const matchingEntry = entries.find((entry) => entry.data.code === code);
 
     if (matchingEntry) {
-      // The manifest ID is the canonical URL path (e.g., "/blog/slug")
+      // The manifest ID is the canonical URL path (e.g., "/blog/slug" or "/micro#123")
+      // Handle hash fragments explicitly — setting URL.pathname encodes '#' as '%23'
+      const targetPath = matchingEntry.id;
       const newUrl = new URL(url);
-      newUrl.pathname = matchingEntry.id;
+      const hashIdx = targetPath.indexOf("#");
+      if (hashIdx !== -1) {
+        newUrl.pathname = targetPath.slice(0, hashIdx);
+        newUrl.hash = targetPath.slice(hashIdx);
+      } else {
+        newUrl.pathname = targetPath;
+      }
       return context.redirect(newUrl.toString(), 301);
     }
   }

src/pages/micro.astro

@@ -9,6 +9,11 @@ const PAGE_SIZE = 20;
 const cursorParam = Astro.url.searchParams.get("cursor");
 const direction = Astro.url.searchParams.get("dir") || "next";
 
+// Validate cursor before using it
+if (cursorParam !== null && !Number.isFinite(Number(cursorParam))) {
+  return Astro.redirect("/micro", 302);
+}
+
 // Get micro posts from D1 via content collection
 const allPosts = (await getCollection("micro")).sort(
   (a, b) => b.data.createdAt.valueOf() - a.data.createdAt.valueOf()
@@ -28,7 +33,7 @@ if (!cursorParam) {
     nextCursor = posts[posts.length - 1].data.createdAt.valueOf();
   }
 } else {
-  const cursor = parseInt(cursorParam);
+  const cursor = Number(cursorParam);
 
   if (direction === "prev") {
     // Previous page - get posts newer than cursor
@@ -96,7 +101,7 @@ function formatDate(date: Date): string {
   <div class="space-y-2">
     {
       posts.map((post) => (
-        <article class="border-fg-2 border p-2">
+        <article id={post.id} class="border-fg-2 border p-2">
           <p class="whitespace-pre-wrap break-words">{post.data.content}</p>
           <time class="text-fg-2 mt-1 block text-sm" datetime={post.data.createdAt.toISOString()}>
             {formatDate(post.data.createdAt)}

src/pages/micro/[id].astro

@@ -0,0 +1,31 @@
+---
+import { getCollection } from "astro:content";
+
+export const prerender = false;
+
+const PAGE_SIZE = 20;
+const { id } = Astro.params;
+
+const allPosts = (await getCollection("micro")).sort(
+  (a, b) => b.data.createdAt.valueOf() - a.data.createdAt.valueOf()
+);
+
+const idx = allPosts.findIndex((p) => p.id === id);
+
+if (idx === -1) {
+  return new Response(null, { status: 404 });
+}
+
+const pageNum = Math.floor(idx / PAGE_SIZE);
+
+if (pageNum === 0) {
+  // Post is on the first page — no cursor needed
+  return Astro.redirect(`/micro#${id}`, 302);
+} else {
+  // Cursor is the createdAt of the last post on the preceding page,
+  // which is the boundary that makes dir=next load this page.
+  const cursorPost = allPosts[pageNum * PAGE_SIZE - 1];
+  const cursor = cursorPost.data.createdAt.valueOf();
+  return Astro.redirect(`/micro?cursor=${cursor}&dir=next#${id}`, 302);
+}
+---

src/utils/code.test.ts

@@ -35,6 +35,7 @@ describe("Code.fromDate()", () => {
     expect(Code.fromDate(date, "R").toString()).toBe("R2392");
     expect(Code.fromDate(date, "P").toString()).toBe("P2392");
     expect(Code.fromDate(date, "T").toString()).toBe("T2392");
+    expect(Code.fromDate(date, "M").toString()).toBe("M2392");
   });
 });
 
@@ -113,6 +114,7 @@ describe("Code.fromCode()", () => {
     expect(Code.fromCode("R2391").getKind()).toBe("R");
     expect(Code.fromCode("P2391").getKind()).toBe("P");
     expect(Code.fromCode("T2391").getKind()).toBe("T");
+    expect(Code.fromCode("M2391").getKind()).toBe("M");
   });
 });
 
@@ -180,6 +182,7 @@ describe("getters", () => {
     expect(Code.fromCode("R2392").getKind()).toBe("R");
     expect(Code.fromCode("P2392").getKind()).toBe("P");
     expect(Code.fromCode("T2392").getKind()).toBe("T");
+    expect(Code.fromCode("M2392").getKind()).toBe("M");
   });
 
   it("should return date code via getDateCode()", () => {
@@ -242,4 +245,8 @@ describe("Code.getCollection()", () => {
   it("should return 'talks' for kind T", () => {
     expect(Code.fromCode("T2392").getCollection()).toBe("talks");
   });
+
+  it("should return 'micro' for kind M", () => {
+    expect(Code.fromCode("M2392").getCollection()).toBe("micro");
+  });
 });