Fix Astro npm entrypoints

Restore the published npm entrypoint contract for @fedify/astro by
making tsdown emit dist/*.js and dist/*.d.ts files that match the
package metadata again.

Add a self-reference regression test that exercises the public API
through ESM import and CommonJS require so the packaged entrypoints are
validated the way consumers load them.

Update CHANGES.md with the packaging fix details.

Fixes #699

Assisted-by: Codex:gpt-5.4

Author: dahlia

CHANGES.md

@@ -8,6 +8,16 @@ Version 2.1.6
 
 To be released.
 
+### @fedify/astro
+
+ -  Restored the npm entrypoint contract for `@fedify/astro` by making the
+    build emit _dist/\*.js_ and _dist/\*.d.ts_ files that match the published
+    package metadata again.  This fixes package resolution failures caused by
+    _package.json_ exporting files that did not exist in the npm tarball.
+    [[#699]]
+
+[#699]: https://github.com/fedify-dev/fedify/issues/699
+
 ### @fedify/cli
 
  -  Fixed `fedify lookup` failing to look up URLs on private or localhost

packages/astro/package.json

@@ -61,6 +61,7 @@
     "build": "pnpm --filter @fedify/astro... run build:self",
     "prepack": "pnpm build",
     "prepublish": "pnpm build",
+    "pretest": "pnpm build",
     "test": "node --experimental-transform-types --test"
   }
 }

packages/astro/src/package.test.ts

@@ -0,0 +1,106 @@
+import { deepStrictEqual, strictEqual } from "node:assert/strict";
+import { createRequire } from "node:module";
+import test from "node:test";
+
+const require = createRequire(import.meta.url);
+
+function expectResponse(response: void | Response): Response {
+  if (!(response instanceof Response)) {
+    throw new TypeError("Expected middleware to return a Response");
+  }
+  return response;
+}
+
+test("self-reference ESM import exposes working Astro integration API", async () => {
+  const mod = await import("@fedify/astro");
+
+  strictEqual(typeof mod.fedifyIntegration, "function");
+  strictEqual(typeof mod.fedifyMiddleware, "function");
+
+  const integration = mod.fedifyIntegration();
+  strictEqual(integration.name, "@fedify/astro");
+
+  let capturedConfig: unknown;
+  (
+    integration.hooks as Record<
+      "astro:config:setup",
+      (args: { updateConfig(config: unknown): void }) => void
+    >
+  )["astro:config:setup"]({
+    updateConfig(config) {
+      capturedConfig = config;
+    },
+  });
+  deepStrictEqual(capturedConfig, {
+    vite: {
+      ssr: {
+        noExternal: ["@fedify/fedify", "@fedify/vocab"],
+      },
+    },
+  });
+
+  let capturedRequest: Request | undefined;
+  let capturedContextData: unknown;
+  const middleware = mod.fedifyMiddleware(
+    {
+      fetch(
+        request: Request,
+        options: {
+          contextData: string;
+          onNotAcceptable(request: Request): Promise<Response>;
+        },
+      ) {
+        capturedRequest = request;
+        capturedContextData = options.contextData;
+        return options.onNotAcceptable(request);
+      },
+    } as never,
+    () => "test-context",
+  );
+
+  const request = new Request("https://example.com/");
+  const response = expectResponse(await middleware(
+    { request } as never,
+    () => Promise.resolve(new Response("Not found", { status: 404 })),
+  ));
+  strictEqual(capturedRequest, request);
+  strictEqual(capturedContextData, "test-context");
+  strictEqual(response.status, 406);
+  strictEqual(response.headers.get("Vary"), "Accept");
+});
+
+test(
+  "self-reference CommonJS require exposes working Astro middleware API",
+  { skip: "Deno" in globalThis },
+  async () => {
+    const mod = require("@fedify/astro") as typeof import("@fedify/astro");
+
+    strictEqual(typeof mod.fedifyIntegration, "function");
+    strictEqual(typeof mod.fedifyMiddleware, "function");
+
+    let nextCalled = false;
+    const middleware = mod.fedifyMiddleware(
+      {
+        fetch(
+          _request: Request,
+          options: { onNotFound(request: Request): Promise<Response> },
+        ) {
+          return options.onNotFound(new Request("https://example.com/actor"));
+        },
+      } as never,
+      () => undefined,
+    );
+
+    const response = expectResponse(await middleware(
+      { request: new Request("https://example.com/inbox") } as never,
+      () => {
+        nextCalled = true;
+        return Promise.resolve(new Response("Handled by Astro"));
+      },
+    ));
+
+    strictEqual(nextCalled, true);
+    strictEqual(response.status, 200);
+    strictEqual(await response.text(), "Handled by Astro");
+  },
+);

packages/astro/tsdown.config.ts

@@ -5,4 +5,10 @@ export default defineConfig({
   dts: true,
   format: ["esm", "cjs"],
   platform: "node",
+  outExtensions({ format }) {
+    return {
+      js: format === "cjs" ? ".cjs" : ".js",
+      dts: format === "cjs" ? ".d.cts" : ".d.ts",
+    };
+  },
 });