@rsc-kit/core 0.30.6 → 0.30.8

package/dist/manifest.js.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,+EAA+E;AAC/E,gFAAgF;AAChF,uCAAuC;AACvC,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,oBAAoB","sourcesContent":["// The shape of routes.json — what the build discovered, for a host to read.\n//\n// The build already walks app/ to generate its entries, and every host needs\n// the same facts: which url a component answers, what layouts wrap it, which\n// slots and sections belong to it. Laravel used to scan the tree a second time\n// to work that out; a JS host would have had to write a third walk. This is the\n// one answer, and these are its types.\n//\n// Urls are segments rather than a pattern string, because the pattern is the\n// host's dialect: Laravel writes {slug}, Hono writes :slug, and neither is the\n// build's business.\n\nexport interface RouteSegment {\n  /**\n   * `host`: a `[name]` directory at the top of app/. Bound from the request's\n   * host, never from a path segment - so `example.com/nope` is a 404 rather\n   * than a tenant called \"nope\". See hostRouting.\n   */\n  type: \"static\" | \"param\" | \"catchAll\" | \"host\";\n  value: string;\n}\n\nexport interface ManifestRoute {\n  component: string;\n  segments: RouteSegment[];\n  layouts: string[];\n  loadings: string[];\n  /**\n   * `error.tsx` files above this route, outermost first.\n   *\n   * The nearest one to a failure catches it, the same way the nearest\n   * `loading.tsx` is the fallback. Optional: a manifest from a build before\n   * error boundaries existed has none.\n   */\n  errors?: string[];\n  /**\n   * `middleware.ts` files above this route, outermost first.\n   *\n   * Run before anything at or below them renders, on every path. A check is\n   * not UI, and making it a layout meant the client could decline it: layouts\n   * are skipped on a partial navigation, and what gets skipped is named in a\n   * header nothing can verify.\n   */\n  middleware: string[];\n  slots: Record<string, string>;\n  sections: string[];\n  /**\n   * The host's route-config file beside this page, if it named one, and the\n   * ancestor ones that also apply — outermost first, this page's excluded.\n   *\n   * Relative to the project root: an absolute path is true only on the machine\n   * that produced it, and building in a container is ordinary.\n   */\n  config: string | null;\n  ancestorConfigs: string[];\n  /**\n   * Host middleware names for this route, outermost first.\n   *\n   * Declared in a route.ts beside or above the page. The engine does not know\n   * what they mean — they are the host's own vocabulary — it only runs them\n   * past the host before anything at or below this route renders.\n   *\n   * Empty on a route that named none, and on every route in an app that never\n   * wrote a route.ts, which is why this needs no flag.\n   *\n   * Optional because registration boots from the PREVIOUS build's manifest: a\n   * shape change takes two builds to settle, and a required field would make\n   * the first of those a hard failure rather than a route with no guards.\n   */\n  hostMiddleware?: string[];\n  /**\n   * Whether the page exports generateStaticParams.\n   *\n   * Recorded here so a host can plan a build — which routes to ask for urls,\n   * which to leave on demand — without loading the server bundle first. The\n   * function itself is reached through the bundle's getStaticParams(), because\n   * only the bundle can run it.\n   */\n  staticParams: boolean;\n}\n\nexport interface ManifestIntercept {\n  component: string;\n  slot: string;\n  segments: RouteSegment[];\n  /** (.) same level, (..) one up, (...) from the root. */\n  marker: string;\n}\n\n/**\n * A `route.ts` — an api endpoint rather than a page.\n *\n * Separate from `routes` because it is matched before them and answered\n * without rendering anything: no layouts, no payload, no client. A url cannot\n * be both, and the build refuses one that is.\n */\nexport interface ManifestApiRoute {\n  /** The module name, as the engine's registry keys it. */\n  name: string;\n  /**\n   * The file that answers, relative to the source directory - `app/api/x/route.ts`,\n   * or `app/sitemap.ts` for a route the build synthesised from a metadata file\n   * - so a line about the route can say where to look.\n   */\n  source?: string;\n  segments: RouteSegment[];\n  /** Which methods the file exports, so a 405 can name the rest. */\n  methods: string[];\n  /**\n   * `middleware.ts` files above this route, outermost first.\n   *\n   * The same chain a page in that directory runs. A route.ts sits among the\n   * pages it belongs with, so a guard on the directory covers it too —\n   * anything else would mean adding an endpoint under a guarded path silently\n   * opened a hole in it.\n   */\n  middleware: string[];\n  /** Host middleware above this route (`export const middleware = [...]`), outermost first. */\n  hostMiddleware?: string[];\n}\n\nexport interface RouteManifest {\n  version: number;\n  build: {\n    output: string;\n    exportPath: string;\n    payloadName: string;\n    /**\n     * The site's own hosts, bare and lower-case. A request from any other\n     * host is matched with that host's segment in front of its path - see\n     * hostRouting. Absent or empty: every request is the site's own.\n     */\n    hosts?: string[];\n    /**\n     * Whether every response says what built it: `X-Powered-By: rsc-kit` and\n     * a generator meta tag in the document. The name only, never the version.\n     * `X-RSC-Kit` (how a response was served) is sent regardless.\n     */\n    identify?: boolean;\n    /**\n     * Whether any page or section declares `refreshOn`, so the server signs\n     * names - and must refuse to serve, in production, without a key every\n     * instance shares.\n     */\n    refreshOn?: boolean;\n  };\n  routes: ManifestRoute[];\n  intercepts: ManifestIntercept[];\n  /** Optional: a manifest from a build before api routes existed has none. */\n  apis?: ManifestApiRoute[];\n}\n"]}
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,+EAA+E;AAC/E,gFAAgF;AAChF,uCAAuC;AACvC,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,oBAAoB","sourcesContent":["// The shape of routes.json — what the build discovered, for a host to read.\n//\n// The build already walks app/ to generate its entries, and every host needs\n// the same facts: which url a component answers, what layouts wrap it, which\n// slots and sections belong to it. Laravel used to scan the tree a second time\n// to work that out; a JS host would have had to write a third walk. This is the\n// one answer, and these are its types.\n//\n// Urls are segments rather than a pattern string, because the pattern is the\n// host's dialect: Laravel writes {slug}, Hono writes :slug, and neither is the\n// build's business.\n\nexport interface RouteSegment {\n  /**\n   * `host`: a `[name]` directory at the top of app/. Bound from the request's\n   * host, never from a path segment - so `example.com/nope` is a 404 rather\n   * than a tenant called \"nope\". See hostRouting.\n   */\n  type: \"static\" | \"param\" | \"catchAll\" | \"host\";\n  value: string;\n}\n\nexport interface ManifestRoute {\n  component: string;\n  segments: RouteSegment[];\n  layouts: string[];\n  loadings: string[];\n  /**\n   * `error.tsx` files above this route, outermost first.\n   *\n   * The nearest one to a failure catches it, the same way the nearest\n   * `loading.tsx` is the fallback. Optional: a manifest from a build before\n   * error boundaries existed has none.\n   */\n  errors?: string[];\n  /**\n   * `not-found.tsx` files above this route, outermost first.\n   *\n   * A `notFound()` from this route's page or guard is answered by the nearest\n   * one, rendered inside the layouts above it; the way `error.tsx` is the\n   * nearest above a failure. A url no route owns has no route to ask, and is\n   * answered by the one at the root. Optional: a manifest from a build before\n   * this has none, and the root one answers everything.\n   */\n  notFounds?: string[];\n  /**\n   * `middleware.ts` files above this route, outermost first.\n   *\n   * Run before anything at or below them renders, on every path. A check is\n   * not UI, and making it a layout meant the client could decline it: layouts\n   * are skipped on a partial navigation, and what gets skipped is named in a\n   * header nothing can verify.\n   */\n  middleware: string[];\n  slots: Record<string, string>;\n  sections: string[];\n  /**\n   * The host's route-config file beside this page, if it named one, and the\n   * ancestor ones that also apply — outermost first, this page's excluded.\n   *\n   * Relative to the project root: an absolute path is true only on the machine\n   * that produced it, and building in a container is ordinary.\n   */\n  config: string | null;\n  ancestorConfigs: string[];\n  /**\n   * Host middleware names for this route, outermost first.\n   *\n   * Declared in a route.ts beside or above the page. The engine does not know\n   * what they mean — they are the host's own vocabulary — it only runs them\n   * past the host before anything at or below this route renders.\n   *\n   * Empty on a route that named none, and on every route in an app that never\n   * wrote a route.ts, which is why this needs no flag.\n   *\n   * Optional because registration boots from the PREVIOUS build's manifest: a\n   * shape change takes two builds to settle, and a required field would make\n   * the first of those a hard failure rather than a route with no guards.\n   */\n  hostMiddleware?: string[];\n  /**\n   * Whether the page exports generateStaticParams.\n   *\n   * Recorded here so a host can plan a build — which routes to ask for urls,\n   * which to leave on demand — without loading the server bundle first. The\n   * function itself is reached through the bundle's getStaticParams(), because\n   * only the bundle can run it.\n   */\n  staticParams: boolean;\n}\n\nexport interface ManifestIntercept {\n  component: string;\n  slot: string;\n  segments: RouteSegment[];\n  /** (.) same level, (..) one up, (...) from the root. */\n  marker: string;\n}\n\n/**\n * A `route.ts` — an api endpoint rather than a page.\n *\n * Separate from `routes` because it is matched before them and answered\n * without rendering anything: no layouts, no payload, no client. A url cannot\n * be both, and the build refuses one that is.\n */\nexport interface ManifestApiRoute {\n  /** The module name, as the engine's registry keys it. */\n  name: string;\n  /**\n   * The file that answers, relative to the source directory - `app/api/x/route.ts`,\n   * or `app/sitemap.ts` for a route the build synthesised from a metadata file\n   * - so a line about the route can say where to look.\n   */\n  source?: string;\n  segments: RouteSegment[];\n  /** Which methods the file exports, so a 405 can name the rest. */\n  methods: string[];\n  /**\n   * `middleware.ts` files above this route, outermost first.\n   *\n   * The same chain a page in that directory runs. A route.ts sits among the\n   * pages it belongs with, so a guard on the directory covers it too —\n   * anything else would mean adding an endpoint under a guarded path silently\n   * opened a hole in it.\n   */\n  middleware: string[];\n  /** Host middleware above this route (`export const middleware = [...]`), outermost first. */\n  hostMiddleware?: string[];\n}\n\nexport interface RouteManifest {\n  version: number;\n  build: {\n    output: string;\n    exportPath: string;\n    payloadName: string;\n    /**\n     * The site's own hosts, bare and lower-case. A request from any other\n     * host is matched with that host's segment in front of its path - see\n     * hostRouting. Absent or empty: every request is the site's own.\n     */\n    hosts?: string[];\n    /**\n     * Whether every response says what built it: `X-Powered-By: rsc-kit` and\n     * a generator meta tag in the document. The name only, never the version.\n     * `X-RSC-Kit` (how a response was served) is sent regardless.\n     */\n    identify?: boolean;\n    /**\n     * Whether any page or section declares `refreshOn`, so the server signs\n     * names - and must refuse to serve, in production, without a key every\n     * instance shares.\n     */\n    refreshOn?: boolean;\n  };\n  routes: ManifestRoute[];\n  intercepts: ManifestIntercept[];\n  /** Optional: a manifest from a build before api routes existed has none. */\n  apis?: ManifestApiRoute[];\n}\n"]}

package/dist/notFound.d.ts

@@ -17,8 +17,8 @@ export declare function isNotFoundDigest(digest: unknown): boolean;
  *
  * Called above every Suspense boundary, the response is a real 404 carrying
  * not-found.tsx. Called inside one, the shell is already on the wire, so the
- * boundary shows its fallback, the status stays 200 and the page ends with a
- * noindex tag. A search engine is answered with the finished page, so it
+ * status stays 200 and the page ends with a noindex tag; the browser then
+ * shows not-found.tsx where the page was. A search engine is answered with the finished page, so it
  * gets a real 404 wherever this was called.
  */
 export declare function notFound(): never;

package/dist/notFound.js

@@ -22,8 +22,9 @@
 //   lookup at the top of a page lands.
 //
 //   After the shell — the status line is gone. React carries an error digest
-//   for every server error, so the mark travels there and the boundary around
-//   it shows its fallback rather than a stack.
+//   for every server error, so the mark travels there. The browser's boundary
+//   takes it for the page's answer, not a failure, and asks the server for
+//   not-found.tsx to put where the page was - layouts kept, the url as it is.
 //   The page ends with a noindex tag, and a crawler - which is answered with
 //   the finished document, see crawler.ts - gets a real 404 regardless.
 /**
@@ -99,8 +100,8 @@ export function isNotFoundDigest(digest) {
  *
  * Called above every Suspense boundary, the response is a real 404 carrying
  * not-found.tsx. Called inside one, the shell is already on the wire, so the
- * boundary shows its fallback, the status stays 200 and the page ends with a
- * noindex tag. A search engine is answered with the finished page, so it
+ * status stays 200 and the page ends with a noindex tag; the browser then
+ * shows not-found.tsx where the page was. A search engine is answered with the finished page, so it
  * gets a real 404 wherever this was called.
  */
 export function notFound() {

package/dist/notFound.js.map

@@ -1 +1 @@
-{"version":3,"file":"notFound.js","sourceRoot":"","sources":["../src/notFound.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,EAAE;AACF,uDAAuD;AACvD,EAAE;AACF,yDAAyD;AACzD,uDAAuD;AACvD,4BAA4B;AAC5B,UAAU;AACV,MAAM;AACN,EAAE;AACF,0EAA0E;AAC1E,8EAA8E;AAC9E,2EAA2E;AAC3E,8EAA8E;AAC9E,oEAAoE;AACpE,EAAE;AACF,yEAAyE;AACzE,kDAAkD;AAClD,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,uCAAuC;AACvC,EAAE;AACF,6EAA6E;AAC7E,8EAA8E;AAC9E,+CAA+C;AAC/C,6EAA6E;AAC7E,wEAAwE;AAExE;;;;;;;;;GASG;AACH,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAA;AAEzD;;;;;;;;;;;;;GAaG;AACH,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAA;AAExD,SAAS,MAAM;IACb,MAAM,KAAK,GAAI,UAAsC,CAAC,KAAK,CAE9C,CAAA;IAEb,MAAM,KAAK,GAAG,KAAK,EAAE,QAAQ,EAAE,CAAA;IAE/B,IAAI,KAAK;QAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAA;AAClC,CAAC;AAED,oEAAoE;AACpE,MAAM,OAAO,cAAe,SAAQ,KAAK;IACvC,YAAY,OAAO,GAAG,WAAW;QAC/B,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAC3B;QAAC,IAA2C,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;QAE1D,wEAAwE;QACxE,uEAAuE;QACvE,gDAAgD;QAChD,MAAM,EAAE,CAAA;IACV,CAAC;CACF;AAED,4EAA4E;AAC5E,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAK,KAAiC,CAAC,IAAI,CAAC,KAAK,IAAI,CACjG,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,GAAG,eAAe,CAAA;AAE9B,kEAAkE;AAClE,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA;AAChD,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,gBAAgB,CAAC,MAAe;IAC9C,OAAO,MAAM,KAAK,MAAM,CAAA;AAC1B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ;IACtB,MAAM,IAAI,cAAc,EAAE,CAAA;AAC5B,CAAC","sourcesContent":["// Saying a url does not name a page, from inside a render.\n//\n//   import { notFound } from '@rsc-kit/core/not-found'\n//\n//   export default async function PostPage({ params }) {\n//     const post = await findPost((await params).slug)\n//     if (!post) notFound()\n//     ...\n//   }\n//\n// Until this existed, \"no such page\" could only be decided by the router,\n// before anything rendered. But most of the time it is not knowable then: the\n// route matched, the url is well-formed, and whether the thing exists is a\n// question only the page can ask. The alternative was an error boundary and a\n// 500, which tells a crawler the page is broken rather than absent.\n//\n// Delivery follows the same two windows a redirect has, and for the same\n// reason — headers flush when the shell resolves:\n//\n//   Before the shell — nothing is written yet, so the host answers 404 and\n//   renders not-found.tsx. This is where a params check lands, and where a\n//   lookup at the top of a page lands.\n//\n//   After the shell — the status line is gone. React carries an error digest\n//   for every server error, so the mark travels there and the boundary around\n//   it shows its fallback rather than a stack.\n//   The page ends with a noindex tag, and a crawler - which is answered with\n//   the finished document, see crawler.ts - gets a real 404 regardless.\n\n/**\n * The mark that says an error is a missing page.\n *\n * A property rather than `instanceof`, for the reason this project keeps\n * meeting: the app's components are bundled apart from the engine that renders\n * them, so each side evaluates its own copy of this module and its own copy of\n * the class. `instanceof` is simply false across that seam — the page would\n * render as an unhandled error, and the only clue would be a 500 where a 404\n * was meant.\n */\nconst MARK = Symbol.for('@rsc-kit/core.not-found-signal')\n\n/**\n * Where a render records that it wants the not-found page.\n *\n * The same scope a redirect records in, reached through the well-known symbol\n * rather than by importing it: this module is evaluated in the app bundle, the\n * engine and the browser, and only one of those should be pulling in the\n * redirect machinery.\n *\n * Recording is necessary because the throw alone does not survive. React\n * catches what a component threw and re-raises its own error, whose message is\n * stripped in production — so the host testing the caught value would work in\n * development and answer 500 in production, which is the worst of the two\n * possible bugs.\n */\nconst SCOPE = Symbol.for('@rsc-kit/core.redirect-scope')\n\nfunction record(): void {\n  const scope = (globalThis as Record<symbol, unknown>)[SCOPE] as\n    | { getStore(): { notFound?: boolean } | undefined }\n    | undefined\n\n  const store = scope?.getStore()\n\n  if (store) store.notFound = true\n}\n\n/** Thrown to stop rendering a page whose subject does not exist. */\nexport class NotFoundSignal extends Error {\n  constructor(message = 'Not found') {\n    super(message)\n    this.name = 'NotFoundSignal'\n    ;(this as unknown as Record<symbol, boolean>)[MARK] = true\n\n    // In the constructor rather than in notFound(), so every way of raising\n    // one is recorded — a params schema refusing is not routed through the\n    // public function and must answer the same way.\n    record()\n  }\n}\n\n/** Whether this is a missing page, whichever copy of the class threw it. */\nexport function isNotFoundSignal(error: unknown): error is NotFoundSignal {\n  return (\n    typeof error === 'object' && error !== null && (error as Record<symbol, unknown>)[MARK] === true\n  )\n}\n\n/**\n * The prefix that carries a missing page inside React's error digest.\n *\n * React replaces a server error's message with an opaque digest in production,\n * and the digest is the one part it is guaranteed to transmit. Kept distinct\n * from the redirect prefix so neither is ever read as the other.\n */\nconst PREFIX = 'RSC_NOT_FOUND'\n\n/** The digest for a missing page, or null for any other error. */\nexport function notFoundDigest(error: unknown): string | null {\n  return isNotFoundSignal(error) ? PREFIX : null\n}\n\n/** Whether a digest describes a missing page. */\nexport function isNotFoundDigest(digest: unknown): boolean {\n  return digest === PREFIX\n}\n\n/**\n * Answer this url with the not-found page.\n *\n * Never returns: it throws, which stops the component that called it. Do not\n * wrap a call in `try`/`catch` without rethrowing what you do not recognise —\n * swallowing this turns a missing page into a blank region.\n *\n * Called above every Suspense boundary, the response is a real 404 carrying\n * not-found.tsx. Called inside one, the shell is already on the wire, so the\n * boundary shows its fallback, the status stays 200 and the page ends with a\n * noindex tag. A search engine is answered with the finished page, so it\n * gets a real 404 wherever this was called.\n */\nexport function notFound(): never {\n  throw new NotFoundSignal()\n}\n"]}
+{"version":3,"file":"notFound.js","sourceRoot":"","sources":["../src/notFound.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,EAAE;AACF,uDAAuD;AACvD,EAAE;AACF,yDAAyD;AACzD,uDAAuD;AACvD,4BAA4B;AAC5B,UAAU;AACV,MAAM;AACN,EAAE;AACF,0EAA0E;AAC1E,8EAA8E;AAC9E,2EAA2E;AAC3E,8EAA8E;AAC9E,oEAAoE;AACpE,EAAE;AACF,yEAAyE;AACzE,kDAAkD;AAClD,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,uCAAuC;AACvC,EAAE;AACF,6EAA6E;AAC7E,8EAA8E;AAC9E,2EAA2E;AAC3E,8EAA8E;AAC9E,6EAA6E;AAC7E,wEAAwE;AAExE;;;;;;;;;GASG;AACH,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAA;AAEzD;;;;;;;;;;;;;GAaG;AACH,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAA;AAExD,SAAS,MAAM;IACb,MAAM,KAAK,GAAI,UAAsC,CAAC,KAAK,CAE9C,CAAA;IAEb,MAAM,KAAK,GAAG,KAAK,EAAE,QAAQ,EAAE,CAAA;IAE/B,IAAI,KAAK;QAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAA;AAClC,CAAC;AAED,oEAAoE;AACpE,MAAM,OAAO,cAAe,SAAQ,KAAK;IACvC,YAAY,OAAO,GAAG,WAAW;QAC/B,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAC3B;QAAC,IAA2C,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;QAE1D,wEAAwE;QACxE,uEAAuE;QACvE,gDAAgD;QAChD,MAAM,EAAE,CAAA;IACV,CAAC;CACF;AAED,4EAA4E;AAC5E,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAK,KAAiC,CAAC,IAAI,CAAC,KAAK,IAAI,CACjG,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,GAAG,eAAe,CAAA;AAE9B,kEAAkE;AAClE,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA;AAChD,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,gBAAgB,CAAC,MAAe;IAC9C,OAAO,MAAM,KAAK,MAAM,CAAA;AAC1B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ;IACtB,MAAM,IAAI,cAAc,EAAE,CAAA;AAC5B,CAAC","sourcesContent":["// Saying a url does not name a page, from inside a render.\n//\n//   import { notFound } from '@rsc-kit/core/not-found'\n//\n//   export default async function PostPage({ params }) {\n//     const post = await findPost((await params).slug)\n//     if (!post) notFound()\n//     ...\n//   }\n//\n// Until this existed, \"no such page\" could only be decided by the router,\n// before anything rendered. But most of the time it is not knowable then: the\n// route matched, the url is well-formed, and whether the thing exists is a\n// question only the page can ask. The alternative was an error boundary and a\n// 500, which tells a crawler the page is broken rather than absent.\n//\n// Delivery follows the same two windows a redirect has, and for the same\n// reason — headers flush when the shell resolves:\n//\n//   Before the shell — nothing is written yet, so the host answers 404 and\n//   renders not-found.tsx. This is where a params check lands, and where a\n//   lookup at the top of a page lands.\n//\n//   After the shell — the status line is gone. React carries an error digest\n//   for every server error, so the mark travels there. The browser's boundary\n//   takes it for the page's answer, not a failure, and asks the server for\n//   not-found.tsx to put where the page was - layouts kept, the url as it is.\n//   The page ends with a noindex tag, and a crawler - which is answered with\n//   the finished document, see crawler.ts - gets a real 404 regardless.\n\n/**\n * The mark that says an error is a missing page.\n *\n * A property rather than `instanceof`, for the reason this project keeps\n * meeting: the app's components are bundled apart from the engine that renders\n * them, so each side evaluates its own copy of this module and its own copy of\n * the class. `instanceof` is simply false across that seam — the page would\n * render as an unhandled error, and the only clue would be a 500 where a 404\n * was meant.\n */\nconst MARK = Symbol.for('@rsc-kit/core.not-found-signal')\n\n/**\n * Where a render records that it wants the not-found page.\n *\n * The same scope a redirect records in, reached through the well-known symbol\n * rather than by importing it: this module is evaluated in the app bundle, the\n * engine and the browser, and only one of those should be pulling in the\n * redirect machinery.\n *\n * Recording is necessary because the throw alone does not survive. React\n * catches what a component threw and re-raises its own error, whose message is\n * stripped in production — so the host testing the caught value would work in\n * development and answer 500 in production, which is the worst of the two\n * possible bugs.\n */\nconst SCOPE = Symbol.for('@rsc-kit/core.redirect-scope')\n\nfunction record(): void {\n  const scope = (globalThis as Record<symbol, unknown>)[SCOPE] as\n    | { getStore(): { notFound?: boolean } | undefined }\n    | undefined\n\n  const store = scope?.getStore()\n\n  if (store) store.notFound = true\n}\n\n/** Thrown to stop rendering a page whose subject does not exist. */\nexport class NotFoundSignal extends Error {\n  constructor(message = 'Not found') {\n    super(message)\n    this.name = 'NotFoundSignal'\n    ;(this as unknown as Record<symbol, boolean>)[MARK] = true\n\n    // In the constructor rather than in notFound(), so every way of raising\n    // one is recorded — a params schema refusing is not routed through the\n    // public function and must answer the same way.\n    record()\n  }\n}\n\n/** Whether this is a missing page, whichever copy of the class threw it. */\nexport function isNotFoundSignal(error: unknown): error is NotFoundSignal {\n  return (\n    typeof error === 'object' && error !== null && (error as Record<symbol, unknown>)[MARK] === true\n  )\n}\n\n/**\n * The prefix that carries a missing page inside React's error digest.\n *\n * React replaces a server error's message with an opaque digest in production,\n * and the digest is the one part it is guaranteed to transmit. Kept distinct\n * from the redirect prefix so neither is ever read as the other.\n */\nconst PREFIX = 'RSC_NOT_FOUND'\n\n/** The digest for a missing page, or null for any other error. */\nexport function notFoundDigest(error: unknown): string | null {\n  return isNotFoundSignal(error) ? PREFIX : null\n}\n\n/** Whether a digest describes a missing page. */\nexport function isNotFoundDigest(digest: unknown): boolean {\n  return digest === PREFIX\n}\n\n/**\n * Answer this url with the not-found page.\n *\n * Never returns: it throws, which stops the component that called it. Do not\n * wrap a call in `try`/`catch` without rethrowing what you do not recognise —\n * swallowing this turns a missing page into a blank region.\n *\n * Called above every Suspense boundary, the response is a real 404 carrying\n * not-found.tsx. Called inside one, the shell is already on the wire, so the\n * status stays 200 and the page ends with a noindex tag; the browser then\n * shows not-found.tsx where the page was. A search engine is answered with the finished page, so it\n * gets a real 404 wherever this was called.\n */\nexport function notFound(): never {\n  throw new NotFoundSignal()\n}\n"]}

package/dist/vite.js

@@ -703,6 +703,7 @@ function routeManifest() {
             layouts: ancestors(name, "layout").map((n) => n),
             loadings: ancestors(name, "loading").map((n) => n),
             errors: ancestors(name, "error"),
+            notFounds: ancestors(name, "not-found"),
             middleware: ancestors(name, "middleware").map((n) => n),
             slots,
             sections: names.filter((n) => SECTION_FILE.test(n + ".tsx") && dirOf(n) === dirOf(name)),
@@ -2953,16 +2954,22 @@ export function instrumentationImport(instrumentation) {
 }
 function generateEntryRsc(fallbackOrigin = "") {
     const instrumentation = instrumentationFile();
-    // The 404 page, if the app has one, and the layouts it renders inside.
-    // Computed here rather than looked up at runtime: not-found is not a route,
-    // so the manifest has no entry to read its chain from.
-    const notFoundComponent = [...components.keys()].find((name) => name.endsWith("/not-found"));
-    const notFoundLayouts = notFoundComponent
-        ? [...components.keys()]
+    // Every 404 page the app has, and the layouts each renders inside. Computed
+    // here rather than looked up at runtime: not-found is not a route, so the
+    // manifest has no entry to read its chain from. Which one answers is decided
+    // per request: the nearest above the route that said notFound(), and for a
+    // url no route owns, the one at the root.
+    const notFoundFiles = [...components.keys()].filter((name) => name.endsWith("/not-found") && !name.includes("/@"));
+    const notFoundLayouts = {};
+    for (const file of notFoundFiles) {
+        notFoundLayouts[file] = [...components.keys()]
             .filter((name) => name.endsWith("/layout") &&
-            notFoundComponent.startsWith(name.slice(0, -"layout".length)))
-            .sort((a, b) => a.length - b.length)
-        : [];
+            file.startsWith(name.slice(0, -"layout".length)))
+            .sort((a, b) => a.length - b.length);
+    }
+    // The root is `app/not-found`: two segments. A nested one alone does not
+    // answer a url nothing owns - it belongs to the routes beneath it.
+    const rootNotFound = notFoundFiles.find((name) => name.split("/").length === 2) ?? null;
     const imports = [];
     const mapEntries = [];
     const metaEntries = [];
@@ -3035,14 +3042,14 @@ import { notFoundDigest, isNotFoundSignal } from ${JSON.stringify(join(packageDi
 import { noteRequestRead, notePageProps, urlOf } from ${JSON.stringify(join(packageDir, "request"))}
 import { redirectDigest } from ${JSON.stringify(join(packageDir, "redirectDigest"))}
 import { cancelledByConsumer } from ${JSON.stringify(join(packageDir, "js/fallbackReport"))}
-import { createRscHandler, pageSaidNotFound, queryAndParams } from ${JSON.stringify(join(packageDir, "host"))}
+import { createRscHandler, notFoundRouteOf, pageSaidNotFound, queryAndParams } from ${JSON.stringify(join(packageDir, "host"))}
 import { httpHostCalls } from ${JSON.stringify(join(packageDir, "hostCalls"))}
 import { backendVersions, installBackendVersionSource } from ${JSON.stringify(join(packageDir, "changed"))}
 import { RefreshOn } from ${JSON.stringify(join(packageDir, "js/refreshOn"))}
 import { prerenderedBeside } from ${JSON.stringify(join(packageDir, "files"))}
 import { renderToReadableStream, decodeReply, decodeAction, decodeFormState, loadServerAction } from '@vitejs/plugin-rsc/rsc'
 import { isQuery, queryCacheControl, isQueryValidationError, queryRefusal } from ${JSON.stringify(join(packageDir, "query"))}
-import { isActionValidationError, isClientBuilt } from ${JSON.stringify(join(packageDir, "action"))}
+import { isActionValidationError, isActionRefusal, isClientBuilt } from ${JSON.stringify(join(packageDir, "action"))}
 import { forgetCached } from ${JSON.stringify(join(packageDir, "cache"))}
 import { noteFallback as noteCaughtRead } from ${JSON.stringify(join(packageDir, "request"))}
 import { isOutdatedOptimizedDep, outdatedDepResponse } from ${JSON.stringify(join(packageDir, "devReload"))}
@@ -3699,6 +3706,21 @@ function checkedSearchParams(
 
 let errorChains: Record<string, string[]> | null = null
 
+let notFoundChains: Record<string, string[]> | null = null
+
+/** The not-found.tsx files above a component, outermost first. */
+function notFoundChain(component: string): string[] {
+  if (!notFoundChains) {
+    notFoundChains = {}
+
+    for (const route of manifest().routes as { component: string; notFounds?: string[] }[]) {
+      if (route.notFounds?.length) notFoundChains[route.component] = route.notFounds
+    }
+  }
+
+  return notFoundChains[component] ?? []
+}
+
 /** The error.tsx files above a component, outermost first. */
 function errorChain(component: string): string[] {
   if (!errorChains) {
@@ -4984,14 +5006,33 @@ export async function handleAction(
   // returned { validationErrors } that <Form> reads. Left thrown, React
   // serialises the rejection opaquely — production strips the message — and the
   // fields it named never reach the browser.
+  //
+  // A refusal is the same: the stub the build writes for a backend action is a
+  // plain function, and when the backend turns the call down (Refuse(503, ...),
+  // abort(429, ...), Rsc::refuse) it throws a refusal whose message was written
+  // for the person asking. Its message is the result's serverError, which is
+  // where a form's formError reads. Its data is not sent: there is no
+  // .refusal(schema) on a plain function to check it against.
   let result: unknown
 
   try {
     result = await (action as (...a: unknown[]) => unknown)(...args)
   } catch (error) {
-    if (!isActionValidationError(error)) throw error
+    if (isActionRefusal(error)) {
+      if (error.data !== undefined) {
+        console.error(
+          '[rsc-kit] ' + actionId + ' refused with data, and is a plain function with no .refusal(schema) to check it - the message was sent, the data was not: ' + error.message,
+        )
+      }
 
-    result = { validationErrors: error.errors }
+      // Marked, so the browser rejects with it when a stub is awaited directly:
+      // a refusal resolved as a result is taken for the success it is typed as.
+      result = { serverError: error.message, __rscRefused: error.refusalStatus }
+    } else if (isActionValidationError(error)) {
+      result = { validationErrors: error.errors }
+    } else {
+      throw error
+    }
   }
 
   // Read after the action has run: what it invalidated is only known once its
@@ -5702,25 +5743,40 @@ function wantsPage(request: Request): boolean {
   return (request.headers.get('Accept') ?? '').includes('text/html')
 }
 
+/**
+ * The not-found.tsx that answers: the nearest above the route that said
+ * notFound(), else - for a url no route owns - the one at the root, else none.
+ */
+function nearestNotFound(request: Request): string | null {
+  const route = notFoundRouteOf(request)
+  const chain = route === undefined ? [] : notFoundChain(route)
+
+  return chain[chain.length - 1] ?? ${JSON.stringify(rootNotFound)}
+}
+
+const NOT_FOUND_LAYOUTS: Record<string, string[]> = ${JSON.stringify(notFoundLayouts)}
+
 async function renderNotFound(request: Request): Promise<Response> {
-  ${notFoundComponent
+  const target = nearestNotFound(request)
+  ${notFoundFiles.length
         ? `
   // A navigation, not a document: answer with the not-found tree as a
   // payload, at the depth the client already holds, so the router renders
   // it in place - the layout stays, the url changes, nothing reloads. The
   // status is still 404; a payload is a payload whatever it says.
-  if (request.headers.get('X-RSC')) {
+  if (target && request.headers.get('X-RSC')) {
     try {
-      const chain = ${JSON.stringify(notFoundLayouts)}
+      const layouts = NOT_FOUND_LAYOUTS[target] ?? []
+      const chain = layouts
       const from = sharedDepth(request.headers.get('X-RSC-Segments'), chain)
       const { rscPayload } = await handleRscPayload(
-        ${JSON.stringify(notFoundComponent)},
+        target,
         {},
-        ${JSON.stringify(notFoundLayouts.map((component) => ({ component, props: {} })))},
+        layouts.map((component) => ({ component, props: {} })),
         [],
         {},
         from,
-        '/404',
+        new URL(request.url).pathname,
       )
 
       return new Response(rscPayload, {
@@ -5739,15 +5795,17 @@ async function renderNotFound(request: Request): Promise<Response> {
   }
 
   try {
+    if (!target) throw new Error('no not-found.tsx')
+
     const { htmlStream } = await handleRscHtmlStream(
-      ${JSON.stringify(notFoundComponent)},
+      target,
       {},
-      ${JSON.stringify(notFoundLayouts.map((component) => ({ component, props: {} })))},
+      (NOT_FOUND_LAYOUTS[target] ?? []).map((component) => ({ component, props: {} })),
       [],
       {},
       {},
       undefined,
-      '/404',
+      new URL(request.url).pathname,
     )
 
     return new Response(htmlStream, {