@absolutejs/absolute 0.20.0-beta.169 → 0.20.0-beta.170

package/dist/src/mobile/androidRelease.d.ts

@@ -41,15 +41,15 @@ export declare const buildAbsoluteAndroidRelease: (options: BuildAbsoluteAndroid
     artifactPath: string;
     metadata: {
         artifact: string;
+        bytes: number;
+        format: typeof ABSOLUTE_ANDROID_RELEASE_FORMAT;
         sha256: string;
         type: "aab";
-        format: typeof ABSOLUTE_ANDROID_RELEASE_FORMAT;
         platform: "android";
         releaseId: string;
         runtime: string;
         appBuild: string;
         appId: string;
-        bytes: number;
         engine: "capacitor" | "expo";
         signed: boolean;
         versionCode?: number | undefined;

package/dist/src/mobile/iosRelease.d.ts

@@ -98,15 +98,15 @@ export declare const buildAbsoluteIosRelease: (options: BuildAbsoluteIosReleaseO
     artifactPath: string;
     metadata: {
         artifact: "App.ipa";
+        bytes: number;
+        format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
         sha256: string;
         type: "ipa";
-        format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
         platform: "ios";
         releaseId: string;
         runtime: string;
         appBuild: string;
         appId: string;
-        bytes: number;
         buildNumber?: number | undefined;
         engine: "capacitor" | "expo";
         marketingVersion: string;
@@ -124,15 +124,15 @@ export declare const installAbsoluteIosRelease: (options: InstallAbsoluteIosRele
     artifactPath: string;
     metadata: {
         artifact: "App.ipa";
+        bytes: number;
+        format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
         sha256: string;
         type: "ipa";
-        format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
         platform: "ios";
         releaseId: string;
         runtime: string;
         appBuild: string;
         appId: string;
-        bytes: number;
         buildNumber?: number | undefined;
         engine: "capacitor" | "expo";
         marketingVersion: string;

package/dist/src/mobile/materializedBundle.d.ts

@@ -23,9 +23,9 @@ export declare const materializeAbsoluteMobileCompatibilityBundle: (input: Absol
 export declare const readAbsoluteMobileMaterializedReleases: (root: string) => Promise<{
     artifact: {
         releaseId: string;
+        format: typeof import("./releaseArtifact").ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
         pages: import("./releaseArtifact").AbsoluteMobileCompatibilityPage[];
         routes: import("./releaseArtifact").AbsoluteMobileCompatibilityRoute[];
-        format: typeof import("./releaseArtifact").ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
         generation: number;
         runtime: string;
         appBuild: string;

package/dist/src/mobile/mobileInspect.d.ts

@@ -144,7 +144,7 @@ export declare const inspectAbsoluteMobileProject: (config: NormalizedAbsoluteMo
     release: {
         checks: {
             id: string;
-            status: "pass" | "warn" | "fail";
+            status: "warn" | "pass" | "fail";
         }[];
         ready: boolean;
     };

package/dist/src/mobile/releaseArtifact.d.ts

@@ -52,9 +52,9 @@ export type AbsoluteMobileResolvedRelease = {
 };
 export declare const createAbsoluteMobileCompatibilityArtifact: (input: AbsoluteMobileCompatibilityArtifactInput) => {
     releaseId: string;
+    format: typeof ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
     pages: AbsoluteMobileCompatibilityPage[];
     routes: AbsoluteMobileCompatibilityRoute[];
-    format: typeof ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
     generation: number;
     runtime: string;
     appBuild: string;
@@ -64,9 +64,9 @@ export declare const createAbsoluteMobileCompatibilityArtifact: (input: Absolute
 export declare const hashAbsoluteMobilePropsSchema: (schema: unknown) => string;
 export declare const parseAbsoluteMobileCompatibilityArtifact: (value: unknown) => {
     releaseId: string;
+    format: typeof ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
     pages: AbsoluteMobileCompatibilityPage[];
     routes: AbsoluteMobileCompatibilityRoute[];
-    format: typeof ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
     generation: number;
     runtime: string;
     appBuild: string;

package/dist/src/mobile/remoteMacProtocol.d.ts

@@ -258,15 +258,15 @@ export declare const buildAbsoluteRemoteIosRelease: (options: BuildAbsoluteRemot
     artifactPath: string;
     metadata: {
         artifact: "App.ipa";
+        bytes: number;
+        format: typeof import("./iosRelease").ABSOLUTE_IOS_RELEASE_FORMAT;
         sha256: string;
         type: "ipa";
-        format: typeof import("./iosRelease").ABSOLUTE_IOS_RELEASE_FORMAT;
         platform: "ios";
         releaseId: string;
         runtime: string;
         appBuild: string;
         appId: string;
-        bytes: number;
         buildNumber?: number | undefined;
         engine: "capacitor" | "expo";
         marketingVersion: string;

package/dist/src/plugins/i18n.d.ts

@@ -0,0 +1,30 @@
+import { Elysia } from 'elysia';
+import type { I18nConfig, I18nInstance, MessageCatalog, RequestI18n } from '../../types/i18n';
+import { type RequestLocale } from '../utils/localeRef';
+export declare const defineI18n: <const Locale extends string, const Default extends Locale, const Catalog extends MessageCatalog>(config: I18nConfig<Locale, Default, Catalog>) => I18nInstance<Locale, Default, Catalog>;
+/** The current request's locale, once `i18nPlugin()` resolved it. */
+export declare const getRequestLocale: () => RequestLocale | undefined;
+/** Resolves every request's locale into the context as `locale` and
+ *  `i18n` (a translator plus `payload()`, `alternates()` and
+ *  `localizePath()`), sets `Content-Language`, and 404s a `:locale` route
+ *  param that is not a configured locale. */
+export declare const i18nPlugin: <const Locale extends string, const Default extends Locale, const Catalog extends MessageCatalog>(i18n: I18nInstance<Locale, Default, Catalog>) => Elysia<"", "local", {
+    decorator: {};
+    store: {};
+    derive: {
+        readonly i18n: RequestI18n<Locale, Catalog>;
+        readonly locale: Locale;
+    };
+}, {
+    typebox: {};
+    error: [];
+}, {
+    schema: {};
+    schemas: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {
+        200: "Not Found";
+    };
+}, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral>;

package/dist/src/plugins/index.d.ts

@@ -1,4 +1,5 @@
 export * from './networking';
-export * from './pageRouter';
 export * from './devtoolsJson';
 export * from './lazyPlugin';
+export * from './secureHeaders';
+export * from './i18n';

package/dist/src/plugins/secureHeaders.d.ts

@@ -0,0 +1,48 @@
+import { Elysia } from 'elysia';
+/** Directive name → sources. `false` removes a default directive. */
+export type CspDirectives = Record<string, readonly string[] | false>;
+export type SecureHeadersOptions = {
+    /** `false` sends no Content-Security-Policy. */
+    contentSecurityPolicy?: false | {
+        /** Merged over the defaults, directive by directive. */
+        directives?: CspDirectives;
+        /** Send `Content-Security-Policy-Report-Only` instead. */
+        reportOnly?: boolean;
+    };
+    /** `X-Content-Type-Options: nosniff`. Default on. */
+    contentTypeOptions?: boolean;
+    /** CSP `frame-ancestors`. Default `["'self'"]`; `false` omits it. */
+    frameAncestors?: readonly string[] | false;
+    /** Feature → allowlist (`[]` disables the feature). `false` omits the
+     *  header. */
+    permissionsPolicy?: Record<string, readonly string[]> | false;
+    /** Default `strict-origin-when-cross-origin`; `false` omits it. */
+    referrerPolicy?: string | false;
+};
+export declare const buildContentSecurityPolicy: (directives: CspDirectives, nonce: string | undefined, extraConnectSources?: readonly string[], extraScriptSources?: readonly string[]) => string;
+/** The headers `secureHeaders(options)` sends for `request`. */
+export declare const securityHeadersFor: (request: Request, options?: SecureHeadersOptions) => Record<string, string>;
+/** The headers the active `secureHeaders()` plugin sends for `request`, or
+ *  null without one. For responses produced before the plugin's hook runs
+ *  (pre-rendered pages). */
+export declare const activeSecurityHeadersFor: (request: Request) => Record<string, string> | null;
+/** @internal Test hook: forgets the active plugin and turns nonces off. */
+export declare const resetSecureHeaders: () => void;
+export declare const secureHeaders: (options?: SecureHeadersOptions) => Elysia<"", "local", {
+    decorator: {};
+    store: {};
+    derive: {
+        /** This request's CSP nonce, for your own inline scripts. */
+        readonly cspNonce: string | undefined;
+    };
+}, {
+    typebox: {};
+    error: [];
+}, {
+    schema: {};
+    schemas: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral>;

package/dist/src/react/components/Head.d.ts

@@ -1,2 +1,2 @@
 import type { Metadata } from '../../../types/metadata';
-export declare const Head: ({ title, description, icon, font, cssPath, canonical, openGraph, twitter, robots, meta, jsonLd, preload, speculationRules }?: Metadata) => import("react/jsx-runtime").JSX.Element;
+export declare const Head: ({ title, description, icon, font, fonts, cssPath, canonical, alternates, openGraph, twitter, robots, meta, jsonLd, preload, speculationRules }?: Metadata) => import("react/jsx-runtime").JSX.Element;

package/dist/src/react/components/StreamSlot.browser.d.ts

@@ -1,5 +1,6 @@
 type StreamSlotProps = {
     className?: string;
+    dynamic?: boolean;
     errorHtml?: string;
     fallbackHtml?: string;
     id: string;

package/dist/src/react/components/StreamSlot.d.ts

@@ -1,10 +1,14 @@
 type StreamSlotProps = {
     className?: string;
+    /** Stream this slot on every request even when the page is
+     *  pre-rendered (partial prerendering): the cached shell keeps the
+     *  fallback. Set it on anything that reads the request or must be fresh. */
+    dynamic?: boolean;
     errorHtml?: string;
     fallbackHtml?: string;
     id: string;
     resolve: () => Promise<string> | string;
     timeoutMs?: number;
 };
-export declare const StreamSlot: ({ className, errorHtml, fallbackHtml, id, resolve, timeoutMs }: StreamSlotProps) => import("react/jsx-runtime").JSX.Element;
+export declare const StreamSlot: ({ className, dynamic, errorHtml, fallbackHtml, id, resolve, timeoutMs }: StreamSlotProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/react/components/SuspenseSlot.browser.d.ts

@@ -1,6 +1,7 @@
 import type { ReactNode } from 'react';
 type LegacySuspenseSlotProps = {
     className?: string;
+    dynamic?: boolean;
     errorHtml?: string;
     fallbackHtml?: string;
     id: string;
@@ -10,6 +11,7 @@ type LegacySuspenseSlotProps = {
 type FrameworkSuspenseSlotProps<T = unknown> = {
     children?: ReactNode | ((value: T) => ReactNode);
     className?: string;
+    dynamic?: boolean;
     errorFallback?: ReactNode | ((error: unknown) => ReactNode);
     id: string;
     promise?: Promise<T>;

package/dist/src/react/components/SuspenseSlot.d.ts

@@ -1,6 +1,10 @@
 import type { ReactNode } from 'react';
 type LegacySuspenseSlotProps = {
     className?: string;
+    /** Stream this slot on every request even when the page is
+     *  pre-rendered (partial prerendering): the cached shell keeps the
+     *  fallback. Set it on anything that reads the request or must be fresh. */
+    dynamic?: boolean;
     errorHtml?: string;
     fallbackHtml?: string;
     id: string;
@@ -10,6 +14,10 @@ type LegacySuspenseSlotProps = {
 type FrameworkSuspenseRenderProps<T = unknown> = {
     children: (value: Awaited<T>) => ReactNode;
     className?: string;
+    /** Stream this slot on every request even when the page is
+     *  pre-rendered (partial prerendering): the cached shell keeps the
+     *  fallback. Set it on anything that reads the request or must be fresh. */
+    dynamic?: boolean;
     errorFallback?: ReactNode | ((error: unknown) => ReactNode);
     id: string;
     fallback?: ReactNode;
@@ -24,6 +32,10 @@ type FrameworkSuspenseRenderProps<T = unknown> = {
 type FrameworkSuspenseNodeProps = {
     children?: ReactNode;
     className?: string;
+    /** Stream this slot on every request even when the page is
+     *  pre-rendered (partial prerendering): the cached shell keeps the
+     *  fallback. Set it on anything that reads the request or must be fresh. */
+    dynamic?: boolean;
     errorFallback?: ReactNode | ((error: unknown) => ReactNode);
     id: string;
     promise?: Promise<ReactNode>;

package/dist/src/react/fileRoute.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentType } from 'react';
+import type { FileRouteServerModuleFor } from '../../types/fileRoutes';
+import { type FileRouteAdapterInput } from '../core/fileRouteAdapter';
+type PagePropsOf<PageModule> = PageModule extends {
+    default: ComponentType<infer Props>;
+} ? Props : never;
+type ReactFileRouteInput<Path extends string, PageModule, ServerModule> = FileRouteAdapterInput<Path> & {
+    page: () => Promise<PageModule>;
+    server?: () => Promise<ServerModule>;
+};
+/** One React file route, as written by the generated route module. The
+ *  type arguments check the route at compile time: `ServerModule`'s `load`
+ *  must accept this path's params and return the page component's props
+ *  (and must exist when the page has required props). */
+export declare const reactFileRoute: <Path extends string, PageModule extends {
+    default: unknown;
+}, ServerModule extends FileRouteServerModuleFor<Path, PagePropsOf<PageModule>>>(route: ReactFileRouteInput<Path, PageModule, ServerModule>) => import("..").FileRouteDefinition;
+export {};

package/dist/src/react/hooks/index.d.ts

@@ -1,6 +1,10 @@
 export { Breakpoint, Breakpoints } from '../../../types/mediaQuery';
+export { I18nProvider, useI18n } from './useI18n';
 export { useIslandStore } from './useIslandStore';
 export { UserAgentProvider, useMediaQuery } from './useMediaQuery';
 export { usePrefetch } from './usePrefetch';
 export type { UsePrefetchOptions } from './usePrefetch';
 export type { PrefetchKind, PrefetchMode } from '../../../types/prefetch';
+export { useFormAction } from './useFormAction';
+export type { UseFormActionOptions } from './useFormAction';
+export { formActionReducer, submitFormAction } from '../../client/formActions';

package/dist/src/react/hooks/useFormAction.d.ts

@@ -0,0 +1,42 @@
+import { type FormEvent } from 'react';
+import type { ActionFields, ActionPath, ActionStateOf, AnyFormAction } from '../../../types/formAction';
+export type UseFormActionOptions<Action extends AnyFormAction> = {
+    /** The result a submission without JavaScript left for this page:
+     *  `getActionState(action)` in the route, passed down as a prop. */
+    initialState?: ActionStateOf<Action>;
+    /** Clear the form's fields after a successful submission that doesn't
+     *  redirect. Default true. */
+    resetOnSuccess?: boolean;
+};
+/**
+ * Progressive-enhancement form state for a `defineAction` action:
+ *
+ *   const signup = useFormAction<typeof createUser>('/users', {
+ *   	initialState: props.signupState
+ *   });
+ *   <form {...signup.formProps}>
+ *   	<input name="name" defaultValue={signup.values.name} />
+ *   	{signup.errors.name && <p>{signup.errors.name}</p>}
+ *   	<button disabled={signup.pending}>Save</button>
+ *   </form>
+ *
+ * `formProps` renders a real `method="post"` form, so it works before
+ * hydration and without JavaScript; once hydrated, submissions go through
+ * fetch and `state` / `pending` / `errors` update in place.
+ */
+export declare const useFormAction: <Action extends AnyFormAction = AnyFormAction>(path: ActionPath<Action>, options?: UseFormActionOptions<Action>) => {
+    data: import("../..").ActionData<Action> | undefined;
+    errors: Partial<Record<ActionFields<Action>, string>>;
+    formProps: {
+        action: ActionPath<Action>;
+        encType: string;
+        method: string;
+        onSubmit: (event: FormEvent<HTMLFormElement>) => void;
+    };
+    message: string | undefined;
+    pending: boolean;
+    reset: () => void;
+    state: ActionStateOf<Action>;
+    submit: (body: FormData) => Promise<import("../..").ActionResult<import("../..").ActionData<Action>, ActionFields<Action>>>;
+    values: Partial<Record<ActionFields<Action>, string | string[]>>;
+};

package/dist/src/react/hooks/useI18n.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+import type { I18nPayload, MessageCatalog } from '../../../types/i18n';
+type I18nProviderProps = {
+    /** The payload from the server (`i18n.payload()`), passed down as a
+     *  page prop so the browser hydrates with the same messages. */
+    value: I18nPayload;
+    children?: ReactNode;
+};
+/** Makes a locale's messages available to `useI18n()` below it. */
+export declare const I18nProvider: ({ value, children }: I18nProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<I18nPayload | null>>;
+/** The translator for the nearest `I18nProvider`. Pass your default
+ *  catalog's type to type-check keys and ICU parameters:
+ *  `const { t } = useI18n<typeof en>()`. */
+export declare const useI18n: <Catalog = MessageCatalog>() => import("../..").Translator<Catalog>;
+export {};

package/dist/src/react/index.d.ts

@@ -1,4 +1,6 @@
 export { handleReactPageRequest } from './pageHandler';
+export { reactFileRoute } from './fileRoute';
+export { handleReactServerPageRequest } from './serverComponents/pageHandler';
 export { Island } from './Island';
 export { createTypedIsland } from './createIsland';
 export { useIslandStore } from './hooks/useIslandStore';

package/dist/src/react/server.d.ts

@@ -1 +1,3 @@
+export { reactFileRoute } from './fileRoute';
 export { handleReactPageRequest } from './pageHandler';
+export { handleReactServerPageRequest } from './serverComponents/pageHandler';

package/dist/src/react/serverComponents/constants.d.ts

@@ -0,0 +1,11 @@
+/** Manifest key of the browser entry that hydrates every RSC page. */
+export declare const REACT_SERVER_CLIENT_MANIFEST_KEY = "ReactServerClient";
+/** `asset(manifest, '<Page>RSC')` names a page's react-server bundle. */
+export declare const REACT_SERVER_PAGE_MANIFEST_SUFFIX = "RSC";
+/** Global array the inline Flight payload scripts push into. */
+export declare const REACT_SERVER_PAYLOAD_GLOBAL = "__absoluteReactServerPayload";
+/** Manifest key of the server bundle that renders Flight to HTML. */
+export declare const REACT_SERVER_RENDERER_MANIFEST_KEY = "ReactServerRenderer";
+/** Written next to the react-server page bundles: where the SSR renderer and
+ *  the hydration entry of the same build live. */
+export declare const REACT_SERVER_RUNTIME_FILE = "react-server-runtime.json";

package/dist/src/react/serverComponents/flightPayload.d.ts

@@ -0,0 +1,2 @@
+export declare const flightPayloadScript: (chunk: string, nonce?: string) => string;
+export declare const injectFlightPayload: (html: ReadableStream<Uint8Array>, flight: ReadableStream<Uint8Array>, nonce?: string) => ReadableStream<Uint8Array<ArrayBufferLike>>;

package/dist/src/react/serverComponents/pageHandler.d.ts

@@ -0,0 +1,14 @@
+import { type StreamingSlotEnhancerOptions } from '../../core/responseEnhancers';
+export type ReactServerPageRequestInput<Props extends Record<string, unknown> = Record<never, never>> = StreamingSlotEnhancerOptions & {
+    /** Buffer the response so it can carry a content-hash `ETag`. */
+    bufferStreamForEtag?: boolean;
+    collectStreamingSlots?: boolean;
+    /** `asset(manifest, '<Page>RSC')`: the page's react-server bundle. */
+    page: string;
+    request?: Request;
+} & (keyof Props extends never ? {
+    props?: NoInfer<Props>;
+} : {
+    props: NoInfer<Props>;
+});
+export declare const handleReactServerPageRequest: <Props extends Record<string, unknown> = Record<never, never>>(input: ReactServerPageRequestInput<Props>) => Promise<Response>;

package/dist/src/svelte/browser.d.ts

@@ -1,3 +1,4 @@
+export { getI18n, setI18n } from './i18n';
 export { createTypedIsland } from './createIsland.browser';
 export { resolveIslandHtml } from './resolveIslandHtml.browser';
 export { useIslandStore } from './islandStore';

package/dist/src/svelte/fileRoute.d.ts

@@ -0,0 +1,15 @@
+import type { FileRouteServerModuleFor } from '../../types/fileRoutes';
+import type { SveltePropsOf } from '../../types/svelte';
+import { type FileRouteAdapterInput } from '../core/fileRouteAdapter';
+type PagePropsOf<PageModule> = PageModule extends {
+    default: infer Page;
+} ? SveltePropsOf<Page> : never;
+/** One Svelte file route, as written by the generated route module. The page
+ *  renders from its compiled module in the manifest; `PageModule` (the
+ *  `.svelte` file's type) only types the props `load` has to return. */
+export declare const svelteFileRoute: <Path extends string, PageModule extends {
+    default: unknown;
+}, ServerModule extends FileRouteServerModuleFor<Path, PagePropsOf<PageModule>>>(route: FileRouteAdapterInput<Path> & {
+    server?: () => Promise<ServerModule>;
+}) => import("..").FileRouteDefinition;
+export {};

package/dist/src/svelte/i18n.d.ts

@@ -0,0 +1,8 @@
+import type { I18nPayload, MessageCatalog } from '../../types/i18n';
+/** The translator `setI18n()` shared from an ancestor component. */
+export declare const getI18n: <Catalog = MessageCatalog>() => import("..").Translator<Catalog>;
+/** Call in the page component with the payload prop from the server:
+ *  shares the locale's messages with every component below (`getI18n()`)
+ *  and returns this page's translator. Pass your default catalog's type
+ *  to type-check keys and ICU parameters. */
+export declare const setI18n: <Catalog = MessageCatalog>(payload: I18nPayload) => import("..").Translator<Catalog>;

package/dist/src/svelte/index.d.ts

@@ -1,4 +1,6 @@
 export { handleSveltePageRequest } from './pageHandler';
+export { svelteFileRoute } from './fileRoute';
+export { getI18n, setI18n } from './i18n';
 export { createTypedIsland } from './createIsland';
 export { useIslandStore } from './islandStore';
 export { renderIsland } from './renderIsland';

package/dist/src/svelte/lowerAwaitSlotSyntax.d.ts

@@ -1,4 +1,8 @@
-export declare const lowerSvelteAwaitSlotSyntax: (source: string) => {
+export declare const AWAIT_STREAM_DIRECTIVE = "<!-- absolute:stream -->";
+/** Lowers every `{#await}` marked with `AWAIT_STREAM_DIRECTIVE` to a
+ *  streaming slot and leaves every other block to Svelte. Throws for a
+ *  marked block it can't stream. */
+export declare const lowerSvelteAwaitSlotSyntax: (source: string, filePath?: string) => {
     code: string;
     transformed: boolean;
 };

package/dist/src/svelte/renderToReadableStream.d.ts

@@ -1,7 +1,9 @@
 import type { Component, ComponentProps } from 'svelte';
 export declare const SVELTE_PAGE_ROOT_ID = "__absolute_svelte_root__";
 export type RenderStreamOptions = {
-    bootstrapScriptContent?: string;
+    /** Inline script before the bootstrap scripts. A function is called
+     *  after the render, so it can describe what the render did. */
+    bootstrapScriptContent?: string | (() => string);
     bootstrapScripts?: string[];
     bootstrapModules?: string[];
     nonce?: string;
@@ -10,5 +12,11 @@ export type RenderStreamOptions = {
     signal?: AbortSignal;
     headContent?: string;
     bodyContent?: string;
+    /** Svelte context for the root component (`render(…, { context })`). */
+    context?: Map<unknown, unknown>;
+    /** Called after each render pass; resolve `true` to render again (up
+     *  to {@link MAX_RENDER_PASSES} passes). The Svelte router uses it to
+     *  await guards and lazy routes between passes. */
+    settle?: () => Promise<boolean>;
 };
-export declare const renderToReadableStream: <Comp extends Component<Record<string, unknown>>>(component: Comp, props?: ComponentProps<Comp>, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError, progressiveChunkSize, signal, headContent, bodyContent }?: RenderStreamOptions) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+export declare const renderToReadableStream: <Comp extends Component<Record<string, unknown>>>(component: Comp, props?: ComponentProps<Comp>, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError, progressiveChunkSize, signal, headContent, bodyContent, context, settle }?: RenderStreamOptions) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;

package/dist/src/svelte/router/browser.d.ts

@@ -1,4 +1,6 @@
 export { goto } from './goto';
+export { NavigationRedirect, redirect } from './guards';
+export { beforeNavigate, preloadRoute } from './navigation';
 export { page } from './page.svelte';
 export { pushState, replaceState } from './pushState';
-export type { ExtractRouteParams, GotoOptions, LinkPrefetchMode, PageState, RouterMode } from '../../../types/svelteRouter';
+export type { ExtractRouteParams, GotoOptions, LazyRouteLoader, LazyRouteModule, LinkPrefetchMode, NavigationContext, NavigationOutcome, NavigationRedirectTarget, NavigationType, PageState, RouteGuard, RouteGuardResult, RouterMode } from '../../../types/svelteRouter';

package/dist/src/svelte/router/goto.d.ts

@@ -1,15 +1,18 @@
-import type { GotoOptions, RouterMode } from '../../../types/svelteRouter';
+import type { GotoOptions } from '../../../types/svelteRouter';
+export { setRouterMode } from './navigation';
 /**
- * Internal — called by Router.svelte on mount so navigation primitives
- * know which URL strategy to use. Hash mode rewrites the URL bar to
- * `#/path` instead of `/path`.
- */
-export declare const setRouterMode: (mode: RouterMode) => void;
-/**
- * Programmatically navigate to a URL. Updates `page.url`, writes history,
- * and (when supported) wraps the swap in `document.startViewTransition`.
+ * Programmatically navigate to a URL. Runs the navigation guards
+ * (`beforeNavigate`, `<Router guard>`, `<Route guard>`), then updates
+ * `page.url`, writes history, swaps the route (inside
+ * `document.startViewTransition` when supported) and scrolls: to the
+ * `#hash` target when the URL has one, otherwise to the top — unless
+ * `noScroll` is set.
+ *
+ * Resolves to what happened: `'committed'`, `'cancelled'` (a guard said
+ * no), `'redirected'`, `'superseded'` (a newer navigation started while a
+ * guard was pending) or `'external'` (another origin; the browser loads it).
  *
  * Mirrors SvelteKit's `goto` from `$app/navigation` — same name, same
  * options shape, so a SvelteKit user finds the primitive familiar.
  */
-export declare const goto: (target: string, options?: GotoOptions) => Promise<void>;
+export declare const goto: (target: string, options?: GotoOptions) => Promise<import("./browser").NavigationOutcome>;

package/dist/src/svelte/router/guards.d.ts

@@ -0,0 +1,43 @@
+import type { NavigationContext, NavigationRedirectTarget, RouteGuard } from '../../../types/svelteRouter';
+export type GuardEntry = {
+    guard: RouteGuard;
+    params: Record<string, string | undefined>;
+};
+export type GuardDecision = {
+    kind: 'allow';
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'redirect';
+    location: string;
+    replace: boolean;
+} | {
+    kind: 'stale';
+};
+export type GuardRunContext = Omit<NavigationContext, 'params'>;
+/** Thrown (or returned) by `redirect()`. An `Error` so a throw from deep
+ *  inside a helper keeps a useful stack; recognised structurally, so a
+ *  copy of the router bundled twice still understands it. */
+export declare class NavigationRedirect extends Error implements NavigationRedirectTarget {
+    redirect: string;
+    replace: boolean;
+    constructor(location: string, replace: boolean);
+}
+/**
+ * Redirect from inside a guard. Return it, or throw it from a helper the
+ * guard calls — both short-circuit the guard chain the same way:
+ *
+ *   guard={({ request }) => {
+ *     if (!isSignedIn(request)) throw redirect('/login');
+ *   }}
+ *
+ * In the browser the redirect adds a history entry unless
+ * `{ replace: true }`; on the server it is a 302.
+ */
+export declare const redirect: (location: string, options?: {
+    replace?: boolean;
+}) => NavigationRedirect;
+/** Run `entries` one after another; the first guard that cancels or
+ *  redirects decides. `isStale` is checked after every guard so a newer
+ *  navigation can abandon this one mid-chain. */
+export declare const runGuardChain: (entries: GuardEntry[], context: GuardRunContext, isStale?: () => boolean) => Promise<GuardDecision>;

package/dist/src/svelte/router/index.d.ts

@@ -1,4 +1,6 @@
 export { goto } from './goto';
+export { NavigationRedirect, redirect } from './guards';
+export { beforeNavigate, preloadRoute } from './navigation';
 export { page } from './page.svelte';
 export { pushState, replaceState } from './pushState';
-export type { ExtractRouteParams, GotoOptions, LinkPrefetchMode, PageState, RouterMode } from '../../../types/svelteRouter';
+export type { ExtractRouteParams, GotoOptions, LazyRouteLoader, LazyRouteModule, LinkPrefetchMode, NavigationContext, NavigationOutcome, NavigationRedirectTarget, NavigationType, PageState, RouteGuard, RouteGuardResult, RouterMode } from '../../../types/svelteRouter';

package/dist/src/svelte/router/lazy.d.ts

@@ -0,0 +1,17 @@
+import type { LazyRouteLoader } from '../../../types/svelteRouter';
+import { type LazyComponent } from './lazyModule';
+/** Forget a failed (or stale) load so the next attempt calls the loader
+ *  again. */
+export declare const forgetLazy: (key: string) => void;
+export declare const hasPendingLazyLoads: () => boolean;
+export declare const lazyCacheKey: (pattern: string, loader: LazyRouteLoader) => string;
+/** Load (once) and cache the component behind `loader`. */
+export declare const loadLazy: (key: string, loader: LazyRouteLoader) => Promise<LazyComponent>;
+/** The component for `key` if it has already loaded — or, during the
+ *  first hydration, the module the hydration entry loaded ahead of time
+ *  for this route pattern. */
+export declare const peekLazy: (key: string, pattern: string) => LazyComponent | undefined;
+/** Resolves once every lazy route load in flight has settled, or after a
+ *  few seconds — scroll restoration waits on this so it doesn't restore a
+ *  position into content that hasn't rendered yet. */
+export declare const whenLazySettled: () => Promise<void>;