@qzsy/vinext 0.1.7

package/dist/plugins/wasm-module-import.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/wasm-module-import.d.ts
+/**
+ * vinext:wasm-module-import — handle `import x from '*.wasm?module'`.
+ *
+ * Resolutions marked external by Vite or a target adapter are preserved. For
+ * non-external resolutions, this plugin reads the WASM file, inlines it as
+ * base64, and exports a compiled WebAssembly.Module.
+ *
+ * Fixes #1351.
+ */
+declare function createWasmModuleImportPlugin(): Plugin;
+//#endregion
+export { createWasmModuleImportPlugin };

package/dist/plugins/wasm-module-import.js

@@ -0,0 +1,50 @@
+import { stripViteModuleQuery } from "../utils/path.js";
+import fs from "node:fs";
+//#region src/plugins/wasm-module-import.ts
+/**
+* vinext:wasm-module-import — handle `import x from '*.wasm?module'`.
+*
+* Resolutions marked external by Vite or a target adapter are preserved. For
+* non-external resolutions, this plugin reads the WASM file, inlines it as
+* base64, and exports a compiled WebAssembly.Module.
+*
+* Fixes #1351.
+*/
+function createWasmModuleImportPlugin() {
+	return {
+		name: "vinext:wasm-module-import",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: /\.wasm\?module$/ },
+			async handler(source, importer) {
+				if (this.environment?.name === "client") return null;
+				if ((importer ? (importer.startsWith("\0") ? importer.slice(1) : importer).split("?")[0] : "").includes("@vercel/og")) return null;
+				const resolved = await this.resolve(source, importer, { skipSelf: true });
+				if (!resolved) return null;
+				if (resolved.external) return resolved;
+				return `\0vinext-wasm-module:${stripViteModuleQuery(resolved.id)}`;
+			}
+		},
+		load: {
+			filter: { id: /^\u0000vinext-wasm-module:/ },
+			handler(id) {
+				const filePath = id.replace(/^\u0000vinext-wasm-module:/, "");
+				this.addWatchFile(filePath);
+				let bytes;
+				try {
+					bytes = fs.readFileSync(filePath);
+				} catch {
+					return this.error(`[vinext] Could not read WASM file: ${filePath}`);
+				}
+				const base64 = bytes.toString("base64");
+				return [
+					`const _b64 = ${JSON.stringify(base64)};`,
+					`const _buf = Uint8Array.from(atob(_b64), c => c.charCodeAt(0));`,
+					`export default await WebAssembly.compile(_buf.buffer);`
+				].join("\n");
+			}
+		}
+	};
+}
+//#endregion
+export { createWasmModuleImportPlugin };

package/dist/routing/app-route-graph.d.ts

@@ -0,0 +1,336 @@
+import { ValidFileMatcher } from "./file-matcher.js";
+import { isInvisibleSegment } from "./utils.js";
+
+//#region src/routing/app-route-graph.d.ts
+type InterceptingRoute = {
+  /** The interception convention: "." | ".." | "../.." | "..." */convention: string; /** The URL pattern this intercepts (e.g. "/photos/:id") */
+  targetPattern: string;
+  /**
+   * URL pattern of the *intercepting route* — the path that owns the slot
+   * containing this interception marker, with route groups and `@slot`
+   * segments stripped. Mirrors Next.js' `interceptingRoute` from
+   * `extractInterceptionRouteInformation`.
+   *
+   * Used at request time to gate `findIntercept` against the Next-URL /
+   * interception-context header: an intercept only fires when the source
+   * pathname matches `^<sourceMatchPattern>(?:/.*)?$`. Without this gate
+   * a direct RSC fetch to the intercept target would render the modal
+   * instead of the underlying page.
+   *
+   * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/generate-interception-routes-rewrites.ts
+   * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/interception-routes.ts
+   */
+  sourceMatchPattern: string; /** Absolute path to the intercepting page component */
+  pagePath: string; /** Filesystem segments from app/ root to the intercepting page directory. */
+  sourcePageSegments?: string[]; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
+  layoutPaths: string[]; /** Parameter names for dynamic segments */
+  params: string[];
+  /**
+   * Synthetic page-carrier slot id for sibling (slot-less) interception.
+   * Set only when the marker has no `@slot` wrapper; undefined for slot intercepts.
+   */
+  slotId?: string;
+};
+type ParallelSlot = {
+  /** Graph-owned semantic slot identity. Required on AppRouteGraphParallelSlot. */id?: string; /** Stable slot identity (name + owning directory), used for route serialization keys. */
+  key: string; /** Slot name (e.g. "team" from @team) */
+  name: string; /** Absolute path to the @slot directory that owns this slot. Internal routing metadata. */
+  ownerDir: string; /** Stable tree path for the directory whose layout owns this slot. */
+  ownerTreePath: string; /** Whether the slot owner directory declares its own page component. */
+  hasPage: boolean; /** Absolute path to the slot's page component */
+  pagePath: string | null; /** Absolute path to the slot's default.tsx fallback */
+  defaultPath: string | null; /** Absolute path to the slot's layout component (wraps slot content) */
+  layoutPath: string | null; /** Absolute path to the slot's loading component */
+  loadingPath: string | null; /** Absolute path to the slot's error component */
+  errorPath: string | null; /** Intercepting routes within this slot */
+  interceptingRoutes: InterceptingRoute[];
+  /**
+   * The layout index (0-based, in route.layouts[]) that this slot belongs to.
+   * Slots are passed as props to the layout at their directory level, not
+   * necessarily the innermost layout. -1 means "innermost" (legacy default).
+   */
+  layoutIndex: number;
+  /**
+   * Filesystem segments from the slot's root directory to its active page.
+   * Used at render time to compute segments for useSelectedLayoutSegment(slotName).
+   * For a page at the slot root (@team/page.tsx), this is [].
+   * For a sub-page (@team/members/page.tsx), this is ["members"].
+   * null when the slot has no active page (showing default.tsx fallback).
+   */
+  routeSegments: string[] | null;
+  /**
+   * Full URL pattern parts for the slot's active page (owner prefix +
+   * slot-relative pattern). Set when an inherited slot mirrors a sub-page
+   * whose param names may differ from the route's. The runtime matches the
+   * request URL against these parts to extract slot-specific params.
+   */
+  slotPatternParts?: string[];
+  /**
+   * Param names captured by `slotPatternParts`, in order of appearance.
+   * Used at runtime to decide whether to extract slot-specific params or
+   * reuse the route's matched params.
+   */
+  slotParamNames?: string[];
+};
+type AppRoute = {
+  /** Graph-owned semantic identities. Required on AppRouteGraphRoute. */ids?: AppRouteSemanticIds; /** URL pattern, e.g. "/" or "/about" or "/blog/:slug" */
+  pattern: string; /** Absolute file path to the page component */
+  pagePath: string | null; /** Absolute file path to the route handler (route.ts) */
+  routePath: string | null; /** Ordered list of layout files from root to leaf */
+  layouts: string[]; /** Ordered list of all discovered template files from root to leaf (not necessarily aligned 1:1 with layouts) */
+  templates: string[]; /** Parallel route slots (from @slot directories at the route's directory level) */
+  parallelSlots: ParallelSlot[];
+  /**
+   * Interception markers not wrapped in an `@slot` directory.
+   * On soft-nav, the intercepting page replaces the entire page response.
+   * Empty array when there are no sibling-style interception markers.
+   */
+  siblingIntercepts: InterceptingRoute[]; /** Loading component path */
+  loadingPath: string | null; /** Error component path (leaf directory only) */
+  errorPath: string | null;
+  /**
+   * Per-layout error boundary paths, aligned with the layouts array.
+   * Each entry is the error.tsx at the same directory level as the
+   * corresponding layout (or null if that level has no error.tsx).
+   */
+  layoutErrorPaths: (string | null)[]; /** Per-segment error boundary paths, aligned with errorTreePositions. */
+  errorPaths?: string[]; /** Tree position (directory depth from app/ root) for each error boundary. */
+  errorTreePositions?: number[]; /** Not-found component path (nearest, walking up from page dir) */
+  notFoundPath: string | null;
+  /**
+   * Not-found component paths per layout level (aligned with layouts array).
+   * Each entry is the not-found.tsx at that layout's directory, or null.
+   * Used to create per-layout NotFoundBoundary so that notFound() thrown from
+   * a layout is caught by the parent layout's boundary (matching Next.js behavior).
+   */
+  notFoundPaths: (string | null)[];
+  /**
+   * Forbidden component paths per layout level (aligned with layouts array).
+   * Each entry is the forbidden.tsx at that layout's directory, or null.
+   * Used to create per-layout ForbiddenBoundary.
+   */
+  forbiddenPaths: (string | null)[]; /** Forbidden component path (403) at the route's directory level */
+  forbiddenPath: string | null; /** Unauthorized component path (401) at the route's directory level */
+  unauthorizedPath: string | null; /** Unauthorized component paths per layout level (aligned with layouts array). */
+  unauthorizedPaths: (string | null)[];
+  /**
+   * Filesystem segments from app/ root to the route's directory.
+   * Includes route groups and dynamic segments (as template strings like "[id]").
+   * Used at render time to compute the child segments for useSelectedLayoutSegments().
+   */
+  routeSegments: string[]; /** Tree position (directory depth from app/ root) for each template. */
+  templateTreePositions?: number[];
+  /**
+   * Tree position (directory depth from app/ root) for each layout.
+   * Used to slice routeSegments and determine which segments are below each layout.
+   * For example, root layout = 0, a layout at app/blog/ = 1, app/blog/(group)/ = 2.
+   * Unlike the old layoutSegmentDepths, this counts ALL directory levels including
+   * route groups and parallel slots.
+   */
+  layoutTreePositions: number[]; /** Whether this is a dynamic route */
+  isDynamic: boolean; /** Parameter names for dynamic segments */
+  params: string[]; /** Dynamic parameter names captured by the route's root layout. */
+  rootParamNames?: string[]; /** Pre-split pattern segments (computed once at scan time, reused per request) */
+  patternParts: string[];
+};
+type AppRouteSemanticIds = {
+  route: string;
+  page: string | null;
+  routeHandler: string | null;
+  rootBoundary: RootBoundaryId | null;
+  layouts: readonly string[];
+  templates: readonly string[];
+  /**
+   * Bridge map for the current route metadata shape: keyed by `slot.key`
+   * (`name@relative/path` infrastructure id), value is the graph-owned semantic slot id.
+   */
+  slots: Readonly<Record<string, string>>;
+};
+type AppRouteGraphParallelSlot = ParallelSlot & {
+  id: string;
+};
+type AppRouteGraphRoute = Omit<AppRoute, "ids" | "parallelSlots" | "rootParamNames"> & {
+  ids: AppRouteSemanticIds;
+  parallelSlots: AppRouteGraphParallelSlot[];
+  rootParamNames: string[];
+};
+type Flavor<T, Brand extends string> = T & {
+  readonly __flavor?: Brand;
+};
+type GraphVersion = Flavor<string, "GraphVersion">;
+type RootBoundaryId = Flavor<string, "RootBoundaryId">;
+type RouteManifestRoute = {
+  id: string;
+  pattern: string;
+  patternParts: readonly string[];
+  isDynamic: boolean;
+  paramNames: readonly string[];
+  rootParamNames: readonly string[];
+  rootBoundaryId: RootBoundaryId | null;
+  pageId: string | null;
+  routeHandlerId: string | null;
+  layoutIds: readonly string[];
+  templateIds: readonly string[];
+  slotIds: readonly string[];
+};
+type RouteManifestPage = {
+  id: string;
+  routeId: string;
+  pattern: string;
+};
+type RouteManifestRouteHandler = {
+  id: string;
+  routeId: string;
+  pattern: string;
+};
+type RouteManifestLayout = {
+  id: string;
+  treePath: string;
+  patternParts: readonly string[];
+  paramNames: readonly string[];
+  rootBoundaryId: RootBoundaryId | null;
+};
+type RouteManifestTemplate = {
+  id: string;
+  treePath: string;
+  rootBoundaryId: RootBoundaryId | null;
+  ownerLayoutId: string | null;
+  reset: {
+    kind: "remountSubtree";
+    treePath: string;
+  };
+};
+type RouteManifestSlot = {
+  id: string;
+  key: string;
+  name: string;
+  ownerTreePath: string;
+  ownerLayoutId: string | null;
+  rootBoundaryId: RootBoundaryId | null;
+  defaultId: string | null;
+  hasDefault: boolean;
+  hasPage: boolean;
+};
+type RouteManifestDefault = {
+  id: string;
+  slotId: string;
+  ownerTreePath: string;
+  ownerLayoutId: string | null;
+  rootBoundaryId: RootBoundaryId | null;
+};
+type RouteManifestSlotBindingState = "active" | "default" | "unmatched";
+type RouteManifestSlotBinding = {
+  id: string;
+  routeId: string;
+  slotId: string;
+  ownerLayoutId: string | null;
+  state: RouteManifestSlotBindingState;
+  defaultId: string | null;
+  routeSegments: readonly string[] | null;
+  slotPatternParts?: readonly string[];
+  slotParamNames?: readonly string[];
+};
+type RouteManifestInterception = {
+  id: string;
+  sourcePattern: string;
+  sourcePatternParts: readonly string[];
+  targetPattern: string;
+  targetPatternParts: readonly string[];
+  slotId: string;
+  ownerLayoutId: string | null;
+  interceptingRouteId: string | null;
+  targetRouteId: string | null;
+};
+type RouteManifestBoundaryOutcome = "error" | "forbidden" | "notFound" | "unauthorized";
+type RouteManifestBoundary = {
+  id: string;
+  outcome: RouteManifestBoundaryOutcome;
+  treePath: string;
+  ownerLayoutId: string | null;
+  rootBoundaryId: RootBoundaryId | null;
+};
+type RouteManifestRootBoundary = {
+  id: RootBoundaryId;
+  layoutId: string;
+  treePath: string;
+};
+type StaticSegmentGraph = {
+  routes: ReadonlyMap<string, RouteManifestRoute>;
+  pages: ReadonlyMap<string, RouteManifestPage>;
+  routeHandlers: ReadonlyMap<string, RouteManifestRouteHandler>;
+  layouts: ReadonlyMap<string, RouteManifestLayout>;
+  templates: ReadonlyMap<string, RouteManifestTemplate>;
+  slots: ReadonlyMap<string, RouteManifestSlot>;
+  defaults: ReadonlyMap<string, RouteManifestDefault>;
+  slotBindings: ReadonlyMap<string, RouteManifestSlotBinding>;
+  interceptions: ReadonlyMap<string, RouteManifestInterception>;
+  interceptionsBySlotId: ReadonlyMap<string, readonly RouteManifestInterception[]>;
+  boundaries: ReadonlyMap<string, RouteManifestBoundary>;
+  rootBoundaries: ReadonlyMap<RootBoundaryId, RouteManifestRootBoundary>;
+};
+type RouteManifest = {
+  graphVersion: GraphVersion;
+  segmentGraph: StaticSegmentGraph;
+};
+declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMatcher): Promise<{
+  routes: AppRouteGraphRoute[];
+  routeManifest: RouteManifest;
+}>;
+declare function computeRootParamNames(routeSegments: readonly string[], layoutTreePositions: readonly number[]): string[];
+/**
+ * Find the best route to attach a sibling intercept to, given the directory
+ * that contains the interception marker.
+ *
+ * 1. Exact hit: a route whose page/handler lives directly in `dir`.
+ * 2. Subtree hit: shallowest route whose page lives anywhere under `dir`
+ *    (handles catch-all routes like `/templates/:catchAll+`).
+ * 3. Ancestor walk: walk up the directory tree toward `appDir` looking for
+ *    any of the above. This handles the case where the marker directory has
+ *    no sibling pages at all (e.g. `deep/path/(...)target` with no
+ *    `deep/path/page.tsx`).
+ *
+ * All comparisons happen in forward-slash space: `appDir` is forward-slash
+ * (normalized once in the config hook), but `dir` and route file paths
+ * descend through native `path.join`/`path.dirname`, which reintroduce
+ * backslashes on Windows. Without normalizing, the `current === appDir`
+ * termination never fires there and the walk overshoots the app root.
+ * `routesByDir` keys must be forward-slash dirnames of the route file paths.
+ *
+ * Exported for tests.
+ */
+declare function findOwnerRouteForDir(dir: string, appDir: string, routes: readonly AppRouteGraphRoute[], routesByDir: Map<string, AppRouteGraphRoute>): AppRouteGraphRoute | null;
+/**
+ * Convert filesystem path segments to URL route parts, skipping invisible segments
+ * (route groups, @slots, ".") and converting dynamic segment syntax to Express-style
+ * patterns (e.g. "[id]" → ":id", "[...slug]" → ":slug+").
+ */
+declare function convertSegmentsToRouteParts(segments: readonly string[]): {
+  urlSegments: string[];
+  params: string[];
+  isDynamic: boolean;
+} | null;
+/**
+ * Returns the unique static sibling segment names at each dynamic URL level
+ * of the matched route. Mirrors Next.js's `getStaticSiblingSegments` from
+ * the next-app-loader: for `/products/[id]` with a sibling route at
+ * `/products/sale`, the dynamic `[id]` segment has `staticSiblings: ['sale']`.
+ *
+ * The returned list flattens siblings across all dynamic positions and is
+ * intended for the RSC payload — the client router uses it to determine if
+ * a cached dynamic-route prefetch can be reused when navigating to a static
+ * sibling URL.
+ *
+ * Ported from Next.js: packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+ * (getStaticSiblingSegments).
+ *
+ * Route group segments and parallel-route slot segments are part of the
+ * filesystem tree but not the URL namespace — sibling computation is done on
+ * the URL-level `patternParts`, so they are correctly transparent here.
+ */
+declare function computeAppRouteStaticSiblings(allRoutes: readonly {
+  patternParts?: readonly string[] | null;
+}[], matchedRoute: {
+  patternParts?: readonly string[] | null;
+}): string[];
+//#endregion
+export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };