@solidjs/router 1.0.0-next.8 → 1.0.0

package/dist/types.d.ts

@@ -1,6 +1,5 @@
-import type { Component, Signal } from "solid-js";
-import type { JSX, ResponseEnvelope } from "@solidjs/web";
-declare module "@solidjs/web" {
+import type { Component, JSX, Signal } from "solid-js";
+declare module "solid-js/web" {
     interface RequestEvent {
         response: {
             status?: number;
@@ -12,8 +11,7 @@ declare module "@solidjs/web" {
             cache?: Map<string, CacheEntry>;
             submission?: {
                 input: any;
-                result?: any;
-                error?: any;
+                result: any;
                 url: string;
             };
             dataOnly?: boolean | string[];
@@ -25,42 +23,6 @@ declare module "@solidjs/web" {
 }
 export type Params = Record<string, string | undefined>;
 export type SearchParams = Record<string, string | string[] | undefined>;
-declare const PATH_PARAMS: unique symbol;
-export interface TypedPath<P extends Params = Params> extends JSX.SerializableAttributeValue {
-    readonly [PATH_PARAMS]: P;
-    toString(): string;
-}
-declare const PATH_SEARCH: unique symbol;
-export interface TypedSearchPath<In = SetSearchParams, Out = SearchParams> {
-    readonly [PATH_SEARCH]: {
-        input: In;
-        output: Out;
-    };
-}
-/**
- * The Standard Schema interface (https://standardschema.dev) — vendored as a
- * type so any conforming validator (Valibot, Zod, ArkType, ...) can type a
- * route's `search` without the router depending on a validation library.
- */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-    readonly "~standard": {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
-        readonly types?: {
-            readonly input: Input;
-            readonly output: Output;
-        } | undefined;
-    };
-}
-export type StandardSchemaResult<Output> = {
-    readonly value: Output;
-    readonly issues?: undefined;
-} | {
-    readonly issues: ReadonlyArray<{
-        readonly message: string;
-    }>;
-};
 export type SetParams = Record<string, string | number | boolean | null | undefined>;
 export type SetSearchParams = Record<string, string | string[] | number | number[] | boolean | boolean[] | null | undefined>;
 export interface Path {
@@ -80,7 +42,7 @@ export interface NavigateOptions<S = unknown> {
     state: S;
 }
 export interface Navigator {
-    (to: string | TypedPath | number, options?: Partial<NavigateOptions>): void;
+    (to: string | number, options?: Partial<NavigateOptions>): void;
     (delta: number): void;
 }
 export type NavigatorFactory = (route?: RouteContext) => Navigator;
@@ -92,7 +54,8 @@ export interface LocationChange<S = unknown> {
     rawPath?: string;
 }
 export interface RouterIntegration {
-    signal: [get: () => LocationChange, set: (next: LocationChange) => void];
+    signal: Signal<LocationChange>;
+    create?: (router: RouterContext) => void;
     utils?: Partial<RouterUtils>;
 }
 export type Intent = "initial" | "native" | "navigate" | "preload";
@@ -109,29 +72,15 @@ export interface RouteSectionProps<T = unknown> {
     children?: JSX.Element;
 }
 export type RouteSectionComponent<T = unknown> = Component<RouteSectionProps<T>> | Component<Omit<RouteSectionProps<T>, "children">> | Component<{}>;
-/**
- * A lazy route subtree: a thunk producing the child definitions — typically
- * `() => import("./feature/routes")` (the module's `default` or `routes`
- * export is used). The subtree's code loads on demand (hover intent or
- * navigation kicks it, and the load folds into the navigation transition)
- * but its *types* still flow into `paths` through the import's promise type.
- * Thunks must be deterministic — resolution is cached append-only and shared
- * by every mount, request, and the server's flight collector.
- */
-export type LazyRouteChildren = () => readonly RouteDefinition[] | Promise<readonly RouteDefinition[] | {
-    default: readonly RouteDefinition[];
-} | {
-    routes: readonly RouteDefinition[];
-}>;
 export type RouteDefinition<S extends string | string[] = any, T = any> = {
     path?: S;
     matchFilters?: MatchFilters<S>;
     preload?: RoutePreloadFunc<T>;
-    children?: RouteDefinition | readonly RouteDefinition[] | LazyRouteChildren;
+    children?: RouteDefinition | RouteDefinition[];
     component?: RouteSectionComponent<T>;
-    /** Standard Schema validator for this route's search params; its input type flows into the typed path proxy. */
-    search?: StandardSchemaV1<any, any>;
     info?: Record<string, any>;
+    /** @deprecated use preload */
+    load?: RoutePreloadFunc;
 };
 export type MatchFilter = readonly string[] | RegExp | ((s: string) => boolean);
 export type PathParams<P extends string | readonly string[]> = P extends `${infer Head}/${infer Tail}` ? [...PathParams<Head>, ...PathParams<Tail>] : P extends `:${infer S}?` ? [S] : P extends `:${infer S}` ? [S] : P extends `*${infer S}` ? [S] : [];
@@ -161,14 +110,6 @@ export interface RouteDescription {
     matcher: (location: string) => PathMatch | null;
     matchFilters?: MatchFilters;
     info?: Record<string, any>;
-    /** Present on the placeholder that stands in for an unresolved lazy subtree. */
-    lazy?: LazyBoundary;
-}
-/** Resolution state for a lazy subtree boundary, shared per thunk. */
-export interface LazyBoundary {
-    thunk: LazyRouteChildren;
-    promise?: Promise<readonly RouteDefinition[]>;
-    resolved?: readonly RouteDefinition[];
 }
 export interface Branch {
     routes: RouteDescription[];
@@ -179,7 +120,6 @@ export interface RouteContext {
     parent?: RouteContext;
     child?: RouteContext;
     pattern: string;
-    params: Params;
     path: () => string;
     outlet: () => JSX.Element;
     resolvePath(to: string): string | undefined;
@@ -188,7 +128,7 @@ export interface RouterUtils {
     renderPath(path: string): string;
     parsePath(str: string): string;
     go(delta: number): void;
-    beforeLeave: BeforeLeaveSlot;
+    beforeLeave: BeforeLeaveLifecycle;
     paramsWrapper: (getParams: () => Params, branches: () => Branch[]) => Params;
     queryWrapper: (getQuery: () => SearchParams) => SearchParams;
 }
@@ -196,7 +136,6 @@ export interface RouterContext {
     base: RouteContext;
     location: Location;
     params: Params;
-    wrapParams: (getParams: () => Params) => Params;
     navigatorFactory: NavigatorFactory;
     isRouting: () => boolean;
     /** The target of the in-flight navigation transition, if any. Not reactive. */
@@ -204,7 +143,7 @@ export interface RouterContext {
     matches: () => RouteMatch[];
     renderPath(path: string): string;
     parsePath(str: string): string;
-    beforeLeave: BeforeLeaveSlot;
+    beforeLeave: BeforeLeaveLifecycle;
     preloadRoute: (url: URL, preloadData?: boolean) => void;
     singleFlight: boolean;
     submissions: Signal<Submission<any, any>[]>;
@@ -226,28 +165,39 @@ export interface BeforeLeaveLifecycle {
     subscribe(listener: BeforeLeaveListener): () => void;
     confirm(to: string | number, options?: Partial<NavigateOptions>): boolean;
 }
-/**
- * Lazily-filled holder for the beforeLeave guard. The router and history
- * adapters only carry this empty object; `useBeforeLeave` installs the actual
- * lifecycle on first use so its machinery tree-shakes out of apps that never
- * block navigation.
- */
-export interface BeforeLeaveSlot {
-    current?: BeforeLeaveLifecycle;
-}
 export type Submission<T, U> = {
     readonly input: T;
     readonly result?: U;
     readonly error: any;
+    readonly pending: boolean;
     readonly url: string;
     clear: () => void;
     retry: () => void;
 };
+export type SubmissionStub = {
+    readonly input: undefined;
+    readonly result: undefined;
+    readonly error: undefined;
+    readonly pending: undefined;
+    readonly url: undefined;
+    clear: () => void;
+    retry: () => void;
+};
 export interface MaybePreloadableComponent extends Component {
     preload?: () => void;
 }
 export type CacheEntry = [number, Promise<any>, any, Intent | undefined, Signal<number> & {
     count: number;
 }];
-export type NarrowResponse<T> = T extends ResponseEnvelope<infer U> ? U : Exclude<T, Response>;
-export {};
+export type NarrowResponse<T> = T extends CustomResponse<infer U> ? U : Exclude<T, Response>;
+export type RouterResponseInit = Omit<ResponseInit, "body"> & {
+    revalidate?: string | string[];
+};
+export type CustomResponse<T> = Omit<Response, "clone"> & {
+    customBody: () => T;
+    clone(...args: readonly unknown[]): CustomResponse<T>;
+};
+/** @deprecated */
+export type RouteLoadFunc = RoutePreloadFunc;
+/** @deprecated */
+export type RouteLoadFuncArgs = RoutePreloadFuncArgs;

package/dist/utils.d.ts

@@ -1,8 +1,6 @@
 import type { MatchFilters, PathMatch, RouteDescription, SearchParams, SetSearchParams } from "./types.js";
 export declare const mockBase = "http://sr";
 export declare function normalizePath(path: string, omitSlash?: boolean): string;
-/** Pathname stripped of search/hash and trailing slash, lowercased — the form link matching compares. */
-export declare const comparablePath: (path: string) => string;
 export declare function resolvePath(base: string, path: string, from?: string): string | undefined;
 export declare function invariant<T>(value: T | null | undefined, message: string): T;
 export declare function joinPaths(from: string, to: string): string;

package/dist/utils.js

@@ -6,8 +6,6 @@ export function normalizePath(path, omitSlash = false) {
     const s = path.replace(trimPathRegex, "$1");
     return s ? (omitSlash || /^[?#]/.test(s) ? s : "/" + s) : "";
 }
-/** Pathname stripped of search/hash and trailing slash, lowercased — the form link matching compares. */
-export const comparablePath = (path) => normalizePath(path.split(/[?#]/, 1)[0]).toLowerCase().replace(/\/$/, "");
 export function resolvePath(base, path, from) {
     if (hasSchemeRegex.test(path)) {
         return undefined;

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "1.0.0-next.8",
+  "version": "1.0.0",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -22,15 +22,13 @@
     ".": {
       "solid": "./dist/index.jsx",
       "default": "./dist/index.js"
-    },
-    "./server": "./dist/server.js"
+    }
   },
   "files": [
     "dist"
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@solidjs/web": "2.0.0-beta.22",
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@changesets/cli": "^2.27.10",
@@ -39,25 +37,23 @@
     "@rollup/plugin-terser": "0.4.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "2.0.0-beta.22",
+    "babel-preset-solid": "^1.9.3",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "2.0.0-beta.22",
+    "solid-js": "^1.9.3",
     "typescript": "^5.7.2",
     "vite": "^6.0.0",
-    "vite-plugin-solid": "3.0.0-next.10",
+    "vite-plugin-solid": "^2.11.0",
     "vitest": "^2.1.6"
   },
   "peerDependencies": {
-    "@solidjs/web": ">=2.0.0-beta.22 <2.0.0-experimental.0",
-    "solid-js": ">=2.0.0-beta.22 <2.0.0-experimental.0"
+    "solid-js": "^1.8.6"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",
-    "test": "vitest run && vitest run --config vitest.config.server.ts && npm run test:types",
+    "test": "vitest run && npm run test:types",
     "test:watch": "vitest",
-    "test:server": "vitest run --config vitest.config.server.ts",
     "test:types": "tsc --project tsconfig.test.json",
     "pretty": "prettier --write \"{src,test}/**/*.{ts,tsx}\"",
     "release": "pnpm build && changeset publish"

package/dist/claims.d.ts

@@ -1,21 +0,0 @@
-import type { RouterContext } from "./types.js";
-/**
- * The compiler claims every `a[href]` (and `form[action]`, which this handler
- * ignores) at creation, and the runtime re-claims on `href` writes. This
- * consumer gives each router-managed anchor the link-state vocabulary without
- * a wrapper component:
- *
- * - `aria-current="page"` — the location matches the link exactly
- * - `data-active` — exact or prefix match
- * - `data-pending` — the link is the target of an in-flight navigation
- *
- * Elements are claimed at creation, so late mounts (`<Show>`, `<For>`,
- * portals) are correct immediately. One render effect (owned by the router)
- * subscribes to the location and sweeps a registry of claimed anchors —
- * anchors themselves carry no reactive machinery, just a registry entry
- * removed by their creating owner's cleanup. State is applied once at claim
- * so it is correct before the next navigation; re-claims (an `href` write)
- * are the same one-shot untracked refresh, reading the element's current
- * `href` from the DOM.
- */
-export declare function setupLinkClaims(router: RouterContext, explicitLinks?: boolean): void;

package/dist/claims.js

@@ -1,115 +0,0 @@
-import { registerElementClaim } from "@solidjs/web";
-import { createRenderEffect, getOwner, onCleanup, untrack } from "solid-js";
-import { comparablePath } from "./utils.js";
-/**
- * The compiler claims every `a[href]` (and `form[action]`, which this handler
- * ignores) at creation, and the runtime re-claims on `href` writes. This
- * consumer gives each router-managed anchor the link-state vocabulary without
- * a wrapper component:
- *
- * - `aria-current="page"` — the location matches the link exactly
- * - `data-active` — exact or prefix match
- * - `data-pending` — the link is the target of an in-flight navigation
- *
- * Elements are claimed at creation, so late mounts (`<Show>`, `<For>`,
- * portals) are correct immediately. One render effect (owned by the router)
- * subscribes to the location and sweeps a registry of claimed anchors —
- * anchors themselves carry no reactive machinery, just a registry entry
- * removed by their creating owner's cleanup. State is applied once at claim
- * so it is correct before the next navigation; re-claims (an `href` write)
- * are the same one-shot untracked refresh, reading the element's current
- * `href` from the DOM.
- */
-export function setupLinkClaims(router, explicitLinks) {
-    const basePath = router.base.path();
-    // per-element record; `current` remembers whether we set `aria-current`,
-    // so user-authored values (steppers, breadcrumbs) are never stripped
-    const claimed = new WeakMap();
-    const registry = new Set();
-    function isSvg(el) {
-        return el.namespaceURI === "http://www.w3.org/2000/svg";
-    }
-    /** The comparable pathname when the router manages this anchor, else `undefined`. */
-    function managedPath(a) {
-        if (explicitLinks && !a.hasAttribute("link"))
-            return;
-        const svg = isSvg(a);
-        // claims fire at creation while the element is still in the template's
-        // inert fragment, where the `href` property is not resolved — resolve the
-        // raw attribute against the live document instead
-        const href = svg ? a.href.baseVal : a.getAttribute("href");
-        const target = svg ? a.target.baseVal : a.target;
-        if (target || !href)
-            return;
-        const rel = (a.getAttribute("rel") || "").split(/\s+/);
-        if (a.hasAttribute("download") || rel.includes("external"))
-            return;
-        let url;
-        try {
-            url = new URL(href, document.baseURI);
-        }
-        catch {
-            return;
-        }
-        if (url.origin !== window.location.origin ||
-            (basePath && url.pathname && !url.pathname.toLowerCase().startsWith(basePath.toLowerCase())))
-            return;
-        return comparablePath(url.pathname);
-    }
-    function linkState(a) {
-        // read reactive sources unconditionally so the owning effect stays
-        // subscribed even while the anchor is not router-managed
-        const loc = decodeURI(comparablePath(router.location.pathname));
-        const routing = router.isRouting();
-        const path = managedPath(a);
-        // the root path is a prefix of everything, so it only matches exactly —
-        // there is no per-anchor `end` opt-out like useLinkState has
-        const matches = (target) => path !== undefined && (target === path || (path !== "" && target.startsWith(path + "/")));
-        // effects observe the committed location during a transition, so the
-        // in-flight target comes from pendingTarget — readable here because the
-        // isRouting write flushes after the target is assigned
-        const pending = routing && !!router.pendingTarget && matches(decodeURI(comparablePath(router.pendingTarget.value)));
-        return { active: matches(loc), pending, exact: path !== undefined && loc === path };
-    }
-    function apply(a, rec, { active, pending, exact }) {
-        active ? a.setAttribute("data-active", "") : a.removeAttribute("data-active");
-        pending ? a.setAttribute("data-pending", "") : a.removeAttribute("data-pending");
-        if (exact !== rec.current) {
-            exact ? a.setAttribute("aria-current", "page") : a.removeAttribute("aria-current");
-            rec.current = exact;
-        }
-    }
-    const refresh = (a, rec) => untrack(() => apply(a, rec, linkState(a)));
-    // The one subscription for every anchor: compute tracks the sources
-    // linkState derives from (the in-flight pendingTarget is readable in the
-    // effect phase because the isRouting write flushes after the target is
-    // assigned), the effect phase sweeps the registry untracked.
-    //
-    // `transparent` keeps the effect invisible to the hydration id scheme.
-    // This setup is client-only, so an id-consuming node here has no server
-    // counterpart and every subsequent hydration id would shift by one child
-    // slot — lazy-route lookups miss and hydration leaves server nodes
-    // unclaimed. (The option is honored by the runtime but missing from the
-    // published EffectOptions type, hence the cast.)
-    createRenderEffect(() => (router.location.pathname, router.isRouting()), () => registry.forEach(a => refresh(a, claimed.get(a))), { transparent: true });
-    onCleanup(registerElementClaim(node => {
-        if (node.nodeName.toUpperCase() !== "A")
-            return;
-        const a = node;
-        // re-claim (href changed): the claiming write runs inside another
-        // effect, so refresh without leaking subscriptions into it
-        const existing = claimed.get(a);
-        if (existing)
-            return refresh(a, existing);
-        const rec = { current: false };
-        claimed.set(a, rec);
-        // claims fire during component setup, so an owner is present in
-        // practice to bound the registry entry's lifetime; without one, state
-        // is still applied once at creation
-        if (getOwner()) {
-            registry.add(a);
-            onCleanup(() => registry.delete(a));
-        }
-        refresh(a, rec);
-    }));
-}

package/dist/data/flash.d.ts

@@ -1,21 +0,0 @@
-export { FLASH_COOKIE, hasFlashCookie, clearFlashCookie } from "./flashCookie.js";
-/** What rides the cookie: a Submission minus its lifecycle methods. */
-export interface FlashSubmission {
-    input: any[];
-    url: string;
-    result?: any;
-    error?: any;
-}
-/**
- * Encodes the outcome of a no-JS submission as a Set-Cookie value. `url` is
- * the action url (pathname + search of the server function call) so the
- * seeded submission matches `useSubmission` filters; `thrown` errors land on
- * `error`, returned values on `result` (mirroring the scripted split).
- */
-export declare function encodeFlashCookie(url: string, result: any, input: any[], thrown?: boolean): string;
-/**
- * Decodes the flash cookie out of a request's Cookie header. Returns
- * undefined when absent or unreadable (a malformed cookie must never take
- * down SSR — it is cleared either way).
- */
-export declare function decodeFlashCookie(cookieHeader: string | null): FlashSubmission | undefined;

package/dist/data/flash.js

@@ -1,78 +0,0 @@
-// The no-JS form convention's cookie codec. When a form posts to a server
-// function without the client runtime (no instance header), the server
-// handler redirects back carrying the outcome in a one-shot "flash" cookie;
-// the next SSR pass reads it and seeds the router's submission state so
-// useSubmission() renders the result exactly as a scripted submission would.
-// Both codec halves live in this module so the write (src/server.ts, the
-// handler's handleNoJS) and the read (provided to the router core by
-// data/action.ts) can never drift apart. The cookie's name/clearing live in
-// flashCookie.ts — the only piece the router core itself consumes — so this
-// codec stays out of bundles that never load the action layer.
-import { FLASH_COOKIE, matchFlashCookie } from "./flashCookie.js";
-export { FLASH_COOKIE, hasFlashCookie, clearFlashCookie } from "./flashCookie.js";
-// Form payloads have no JSON encoding, so entries are captured as pair
-// arrays under a marker key ($f / $u) and revived to real FormData /
-// URLSearchParams on the way out. File entries cannot ride a cookie and are
-// dropped.
-function encodeInputValue(value) {
-    if (value instanceof FormData)
-        return { $f: [...value.entries()].filter(([, v]) => typeof v === "string") };
-    if (value instanceof URLSearchParams)
-        return { $u: [...value.entries()] };
-    return value;
-}
-function decodeInputValue(value) {
-    if (value && typeof value === "object") {
-        if (Array.isArray(value.$f)) {
-            const form = new FormData();
-            for (const [k, v] of value.$f)
-                form.append(k, v);
-            return form;
-        }
-        if (Array.isArray(value.$u))
-            return new URLSearchParams(value.$u);
-    }
-    return value;
-}
-/**
- * Encodes the outcome of a no-JS submission as a Set-Cookie value. `url` is
- * the action url (pathname + search of the server function call) so the
- * seeded submission matches `useSubmission` filters; `thrown` errors land on
- * `error`, returned values on `result` (mirroring the scripted split).
- */
-export function encodeFlashCookie(url, result, input, thrown) {
-    const isError = result instanceof Error;
-    const payload = {
-        url,
-        result: isError ? result.message : result,
-        error: isError,
-        thrown: !!thrown,
-        input: input.map(encodeInputValue)
-    };
-    return `${FLASH_COOKIE}=${encodeURIComponent(JSON.stringify(payload))}; Secure; HttpOnly; Path=/`;
-}
-/**
- * Decodes the flash cookie out of a request's Cookie header. Returns
- * undefined when absent or unreadable (a malformed cookie must never take
- * down SSR — it is cleared either way).
- */
-export function decodeFlashCookie(cookieHeader) {
-    const match = matchFlashCookie(cookieHeader);
-    if (!match)
-        return;
-    try {
-        const payload = JSON.parse(decodeURIComponent(match));
-        if (!payload || !payload.result)
-            return;
-        const result = payload.error ? new Error(payload.result) : payload.result;
-        return {
-            input: Array.isArray(payload.input) ? payload.input.map(decodeInputValue) : [],
-            url: payload.url,
-            result: payload.thrown ? undefined : result,
-            error: payload.thrown ? result : undefined
-        };
-    }
-    catch (error) {
-        console.error(error);
-    }
-}

package/dist/data/flashCookie.d.ts

@@ -1,7 +0,0 @@
-export declare const FLASH_COOKIE = "flash";
-/** Whether a Cookie header carries a flash cookie (readable or not). */
-export declare function hasFlashCookie(cookieHeader: string | null): boolean;
-/** The raw encoded flash payload out of a Cookie header, if present. */
-export declare function matchFlashCookie(cookieHeader: string | null): string | undefined;
-/** The Set-Cookie value clearing the flash cookie after it has been read. */
-export declare function clearFlashCookie(): string;

package/dist/data/flashCookie.js

@@ -1,20 +0,0 @@
-// The flash cookie's name and one-shot clearing — split from the codec in
-// flash.ts so the router core can consume the cookie eagerly (the clear must
-// be appended before streaming flushes the response headers, and an unread
-// outcome must not haunt a later request) without carrying the encode/decode
-// machinery into client bundles that never load the action layer.
-export const FLASH_COOKIE = "flash";
-const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
-/** Whether a Cookie header carries a flash cookie (readable or not). */
-export function hasFlashCookie(cookieHeader) {
-    return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
-}
-/** The raw encoded flash payload out of a Cookie header, if present. */
-export function matchFlashCookie(cookieHeader) {
-    const match = cookieHeader && cookieHeader.match(FLASH_MATCHER);
-    return match ? match[1] : undefined;
-}
-/** The Set-Cookie value clearing the flash cookie after it has been read. */
-export function clearFlashCookie() {
-    return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
-}

package/dist/data/serverForms.d.ts

@@ -1 +0,0 @@
-export { submitServerForm } from "./action.js";

package/dist/data/serverForms.js

@@ -1,5 +0,0 @@
-// The delegation fallback's lazy entry (see data/events.ts). Nothing imports
-// this module statically — it exists so the dynamic import has a target that
-// bundlers can keep as a split point: router-only apps never load the action
-// machinery unless a server-action form actually submits.
-export { submitServerForm } from "./action.js";