Build Failure for Dynamic File Endpoints in projects with Trailing Slash "always"

[markconnellypro]

Astro Info

Astro                    v7.0.4
Vite                     v8.1.0
Node                     v24.1.0
System                   Linux (x64)
Package Manager          npm
Output                   static
Adapter                  none
Integrations             none

If this issue only occurs in one browser, which browser is a problem?

N/A

Describe the Bug

Dynamic file endpoints are causing builds to fail with trailingSlash as "always." In 7.0.3, the Minimal Reproducible Example showed 3 static routes generated in the npm run build output; however, for the final 2, it actually created the files without the slash in the dist folder:

• /api/noname.json
• /api/foo.json/
• /api/bar.json/

In 7.0.4, it appears to still be trying to add slashes to the dynamic file endpoints during the build process, and in doing so, is encountering TypeError due to missing parameter.

This does not appear to be affecting non-dynamic file endpoints.

This is likely a bug introduced by #17224

What's the expected result?

The build process should create three files in the Minimal Reproducible Example, which should also be what the npm run build output should show as having been generated:

• api/bar.json
• api/foo.json
• api/noname.json

Link to Minimal Reproducible Example

https://github.com/markconnellypro/astro-trailing-slash/

Participation

• I am willing to submit a pull request for this issue.

[astrobot-houston]

• Reproduced: Yes
• Exploration: Yes — View branch
• Unit Test: Yes — packages/astro/test/units/routing/generator.test.ts
• Priority: P4: important. This is a build-breaking regression introduced in v7.0.4 that affects any project using dynamic file endpoints (e.g. [name].json.ts) with trailingSlash: \"always\". There is no workaround other than downgrading to v7.0.3 or removing trailingSlash: \"always\".

This is a regression from #17224. That PR correctly updated the route pattern regex to use trailingSlash: 'never' for dynamic file endpoints, but missed updating the pathname generation in stringifyParams. During build, stringifyParams still uses the global trailingSlash: 'always' config, producing paths like /api/foo.json/ that don't match the route's own pattern — causing TypeError: Missing parameter: name when the build tries to resolve params.

I found a potential fix for this issue. The fix overrides trailingSlash to 'never' inside stringifyParams when the route is a file endpoint, ensuring pathname generation matches the route pattern. This is a single-file, 6-line change in packages/astro/src/core/routing/params.ts.

Try this fix

You can test this fix right now without waiting for a release:

npm i https://pkg.pr.new/astro@6f92832

If this fixes your issue, please leave a comment letting us know (e.g. "confirmed, this fixes it"). We'll then open a pull request to get this merged.

Full Triage Report

Triage Report: Issue #17241

Issue Title

Build Failure for Dynamic File Endpoints in projects with Trailing Slash "always"

Issue Details

• Author: markconnellypro
• Created: 2026-06-30T18:01:23Z
• URL: Build Failure for Dynamic File Endpoints in projects with Trailing Slash "always" #17241
• Likely cause: PR Fix trailing slash handling for dynamic file endpoints in dev mode #17224 ("Fix trailing slash handling for dynamic file endpoints in dev mode")

Environment

• Astro v7.0.4 (current HEAD: 72e29bd)
• Node.js (runner environment)
• Output: static
• Adapter: none

Bug Description

Dynamic file endpoints (e.g., [name].json.ts) cause build failures when trailingSlash: \"always\" is configured. The build tries to append a trailing slash to the dynamic file endpoint path (e.g., /api/foo.json/) and then fails with TypeError: Missing parameter: name because the path with trailing slash doesn't match the route pattern for parameter extraction.

Non-dynamic file endpoints (e.g., noname.json.ts) are unaffected.

The issue was introduced by commit dc5e52f (PR #17224), which changed trailing slash handling for dynamic file endpoints in dev mode but inadvertently broke the build process.

Reproduction Steps

1. Create a minimal Astro project with trailingSlash: 'always' in astro.config.mjs
2. Add a non-dynamic file endpoint at src/pages/api/noname.json.ts
3. Add a dynamic file endpoint at src/pages/api/[name].json.ts with getStaticPaths() returning params foo and bar
4. Run astro build

Expected Result

Build succeeds, creating three files:

• api/bar.json
• api/foo.json
• api/noname.json

Actual Result

Build fails with TypeError: Missing parameter: name. The build output shows it tries to render /api/foo.json/ (with trailing slash appended), which causes the parameter lookup to fail.

Full Error:

 generating static routes 
  ├─ /api/noname.json (+5ms) 
  ├─ /api/foo.json/
[ERROR] TypeError: Missing parameter: name
    at getParameter (prerender-entry.mjs:258:36)
    at Array.map (<anonymous>)
    at getSegment (prerender-entry.mjs:264:30)
    at Array.map (<anonymous>)
    at stringifyParams (prerender-entry.mjs:293:57)
    at findPathItemByKey (prerender-entry.mjs:457:20)
    at getProps (prerender-entry.mjs:477:28)
[ERROR] [build] Caught error rendering /api/foo.json/: TypeError: Missing parameter: name

Baseline Verification

• Without trailingSlash: 'always': Build succeeds. All three endpoints are generated correctly (/api/noname.json, /api/foo.json, /api/bar.json).
• With trailingSlash: 'always': Build fails as described above. The non-dynamic endpoint /api/noname.json is generated successfully before the error occurs.

Reproduction Result

✅ REPRODUCED — The bug is confirmed and consistently reproducible.

---

Diagnosis

Root Cause

The bug is a regression introduced by PR #17224 (commit dc5e52f96c). That PR correctly fixed the route pattern generation for dynamic file endpoints with trailingSlash: 'always' — the trailingSlashForPath function in create-manifest.ts now returns 'never' for file endpoints (both static and dynamic). This means the route's regex pattern correctly matches paths without a trailing slash (e.g., /api/foo.json).

However, the PR did not update the pathname generation path. During static build, StaticPaths.#getPathsForRoute() in packages/astro/src/runtime/prerender/static-paths.ts (line 119) calls:

const pathname = stringifyParams(staticPath.params, route, manifest.trailingSlash);

This uses manifest.trailingSlash which is 'always' (the global config value). The stringifyParams → getRouteGenerator function in packages/astro/src/core/routing/generator.ts unconditionally appends / when trailingSlash === 'always', producing /api/foo.json/.

This creates a mismatch:

1. Route pattern (regex) expects /api/foo.json (no trailing slash) — correct per PR Fix trailing slash handling for dynamic file endpoints in dev mode #17224
2. Generated pathname is /api/foo.json/ (with trailing slash) — incorrect, not updated by PR Fix trailing slash handling for dynamic file endpoints in dev mode #17224

When the build tries to render /api/foo.json/:

1. getParams(route, '/api/foo.json/') calls route.pattern.exec('/api/foo.json/') which fails because the pattern doesn't match trailing slash
2. getParams returns {} (empty params)
3. findPathItemByKey calls stringifyParams({}, route, 'always') to create a cache key
4. getParameter in generator.ts throws TypeError: Missing parameter: name because the name param is missing from the empty params object

Affected Files

1. packages/astro/src/core/routing/params.ts — stringifyParams passes through trailingSlash without considering file endpoints
2. packages/astro/src/runtime/prerender/static-paths.ts (line 119) — calls stringifyParams with manifest.trailingSlash
3. packages/astro/src/core/render/route-cache.ts (lines 79, 144) — also calls stringifyParams with the global trailingSlash

Confidence: high

---

Verification

Verdict: bug

Confidence: high

This is an unambiguous regression. PR #17224 partially fixed trailing slash handling for dynamic file endpoints (route pattern only) but missed the build-time pathname generation path. The developer did not know about or choose this build failure — it was an oversight in the scope of the fix.

---

Fix

File: packages/astro/src/core/routing/params.ts

Modified stringifyParams to override trailingSlash to 'never' when the route is a file endpoint (type 'endpoint' with a file extension in the route string). Applied inside stringifyParams itself so all callers automatically get the correct behavior.

Unit Test

Added 3 test cases to packages/astro/test/units/routing/generator.test.ts:

1. Core regression test: dynamic file endpoint with trailingSlash: 'always' produces path without trailing slash
2. Guard against over-correction: page routes still get trailing slashes
3. Baseline: endpoints without file extensions are unchanged

All existing routing tests continue to pass.

Fix Result: ✅ SUCCESS

This report was made by an LLM. The analysis may be wrong, and the potential fix might not work, but is intended as a starting point for exploring the issue.

[markconnellypro]

Hello,

I tested this on the Minimal Reproducible Example, a private static project, and a private server project. I ran both npm run dev and npm run build and examined the functionality and outputs. Confirmed, this fixes it.

Thank you.

[astrobot-houston]

The fix has been verified! A pull request has been created: #17246

[alexhopes]

Still reproduces on astro@7.0.7 (verified against the published tarball, not just the PR state).

Hit this on a real project: a dynamic RSS endpoint src/pages/feed/pinterest/[topic].xml.ts with trailingSlash: 'always', which fails the build with TypeError: Missing parameter: topic.

Root cause

The per-route trailing-slash value is computed correctly, but never reaches the path generator — only the pattern.

core/routing/create-manifest.js derives it and bakes it into route.pattern:

const trailingSlashForPath = (pathname, config, type, route) =>
  type === "endpoint" && hasFileExtension(pathname ?? route ?? "") ? "never" : config.trailingSlash;
// ...
const pattern = getPattern(segments, settings.config.base, trailingSlash);

…but the object pushed onto routes never stores that value. So downstream, runtime/prerender/static-paths.js falls back to the global config (7.0.7, line 63):

const pathname = stringifyParams(staticPath.params, route, manifest.trailingSlash);

stringifyParams (core/routing/params.js) passes it straight to getRouteGenerator, which appends / for "always". The result is a generated pathname that cannot match its own route pattern:

• pattern (built with "never"): ^\/feed\/pinterest\/([^/]+?)\.xml$
• generated (built with "always"): /feed/pinterest/tiere.xml/

The pathname then fails to re-match, params come back empty, and getParameter throws Missing parameter: topic.

That also explains @markconnellypro's observation that non-dynamic file endpoints are unaffected — a static endpoint has no params to stringify, so it never goes through this path.

Same fallback exists in core/render/route-cache.js (callGetStaticPaths keying and findPathItemByKey), which is why the params key and the pathname disagree.

Re: #17246

The approach there — storing trailingSlash on RouteData and using route.trailingSlash ?? trailingSlash at each call site — looks like the correct fix, since the missing per-route value is exactly what's absent from routes.push({ … }). Anything blocking it? Happy to help test.

Interim workaround

For anyone else stuck: patching stringifyParams to re-derive the value works, and is idempotent (a caller already passing "never" is unaffected), since it just mirrors trailingSlashForPath:

const effectiveTrailingSlash =
  route.type === "endpoint" && hasFileExtension(route.pathname ?? route.route ?? "")
    ? "never"
    : trailingSlash;

This fixes all three call sites at once (static-paths.js, and both in route-cache.js) because they all funnel through stringifyParams.

[fflaten]

Looks like 7.0.8 fixed this with #17320 - at least in my project.

[markconnellypro]

Looks like 7.0.8 fixed this with #17320 - at least in my project.

This fixes it in the Minimal Reproducible Example. Will close this issue.