@absolutejs/absolute 0.19.0-beta.1043 → 0.19.0-beta.1044

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

@@ -0,0 +1,58 @@
+import { Elysia } from 'elysia';
+export type DevtoolsJsonOptions = {
+    projectRoot?: string;
+    uuid?: string;
+    uuidCachePath?: string;
+    normalizeForWindowsContainer?: boolean;
+};
+export declare const resolveDevtoolsUuidCachePath: (buildDir: string, uuidCachePath?: string) => string;
+export declare const devtoolsJson: (buildDir: string, options?: DevtoolsJsonOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    ".well-known": {
+        appspecific: {
+            "com.chrome.devtools.json": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            workspace: {
+                                root: string;
+                                uuid: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const normalizeDevtoolsWorkspaceRoot: (root: string) => string;

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

@@ -0,0 +1,163 @@
+import Elysia from 'elysia';
+import type { HMRState } from '../dev/clientManager';
+export declare const hmr: (hmrState: HMRState, manifest: Record<string, string>, moduleServerHandler?: (pathname: string) => Promise<Response | undefined> | Response | undefined) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    "@src": {
+        "*": {
+            get: {
+                body: unknown;
+                params: {
+                    "*": string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    "@stub": {
+        "*": {
+            get: {
+                body: unknown;
+                params: {
+                    "*": string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    "@hmr": {
+        "*": {
+            get: {
+                body: unknown;
+                params: {
+                    "*": string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    "@ng": {
+        "*": {
+            get: {
+                body: unknown;
+                params: {
+                    "*": string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    hmr: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    "hmr-status": {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | {
+                    connectedClients: number;
+                    isRebuilding: boolean;
+                    manifestKeys: string[];
+                    rebuildCount: number;
+                    rebuildQueue: string[];
+                    timestamp: number;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response;
+    };
+}>;

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

@@ -0,0 +1,67 @@
+import { Elysia } from 'elysia';
+import type { ImageConfig } from '../../types/image';
+export declare const imageOptimizer: (config: ImageConfig | undefined, buildDir: string) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}> | Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

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

@@ -0,0 +1,3 @@
+export * from './networking';
+export * from './pageRouter';
+export * from './devtoolsJson';

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

@@ -0,0 +1,2 @@
+import { Elysia } from 'elysia';
+export declare const networking: <A extends Elysia>(app: A) => A;

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

@@ -0,0 +1 @@
+export declare const pageRouterPlugin: () => void;

package/dist/src/react/Island.browser.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeIslandRenderProps } from '../../types/island';
+export declare const Island: (props: RuntimeIslandRenderProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { RuntimeIslandRenderProps } from '../../types/island';
+export declare const Island: (props: RuntimeIslandRenderProps) => Promise<import("react/jsx-runtime").JSX.Element>;

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

@@ -0,0 +1 @@
+export declare const bridgeReactInternals: () => Promise<void>;

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

@@ -0,0 +1,3 @@
+export { Island } from './Island.browser';
+export { createTypedIsland } from './createIsland.browser';
+export { useIslandStore } from './hooks/useIslandStore';

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

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

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

@@ -0,0 +1,2 @@
+import type { ImageProps } from '../../../types/image';
+export declare const Image: ({ alt, blurDataURL, className, crossOrigin, fetchPriority, fill, height, loader, loading, onError, onLoad, overrideSrc, placeholder, priority, quality, referrerPolicy, sizes, src, style, unoptimized, width }: ImageProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+import type { JsonLdSchema } from '../../../types/jsonLd';
+export declare const JsonLd: ({ schema }: {
+    schema: JsonLdSchema | JsonLdSchema[];
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+type StreamSlotProps = {
+    className?: string;
+    errorHtml?: string;
+    fallbackHtml?: string;
+    id: string;
+    resolve: () => Promise<string> | string;
+    timeoutMs?: number;
+};
+export declare const StreamSlot: ({ className, fallbackHtml, id }: StreamSlotProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+type StreamSlotProps = {
+    className?: string;
+    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 {};

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

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+type LegacySuspenseSlotProps = {
+    className?: string;
+    errorHtml?: string;
+    fallbackHtml?: string;
+    id: string;
+    resolve: () => Promise<string> | string;
+    timeoutMs?: number;
+};
+type FrameworkSuspenseSlotProps<T = unknown> = {
+    children?: ReactNode | ((value: T) => ReactNode);
+    className?: string;
+    errorFallback?: ReactNode | ((error: unknown) => ReactNode);
+    id: string;
+    promise?: Promise<T>;
+    resolve?: () => Promise<T | ReactNode> | T | ReactNode;
+    fallback?: ReactNode;
+    timeoutMs?: number;
+};
+type SuspenseSlotProps<T = unknown> = LegacySuspenseSlotProps | FrameworkSuspenseSlotProps<T>;
+export declare const SuspenseSlot: <T>(props: SuspenseSlotProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,37 @@
+import type { ReactNode } from 'react';
+type LegacySuspenseSlotProps = {
+    className?: string;
+    errorHtml?: string;
+    fallbackHtml?: string;
+    id: string;
+    resolve: () => Promise<string> | string;
+    timeoutMs?: number;
+};
+type FrameworkSuspenseRenderProps<T = unknown> = {
+    children: (value: Awaited<T>) => ReactNode;
+    className?: string;
+    errorFallback?: ReactNode | ((error: unknown) => ReactNode);
+    id: string;
+    fallback?: ReactNode;
+    timeoutMs?: number;
+} & ({
+    promise: Promise<T>;
+    resolve?: undefined;
+} | {
+    promise?: undefined;
+    resolve: () => Promise<T> | T;
+});
+type FrameworkSuspenseNodeProps = {
+    children?: ReactNode;
+    className?: string;
+    errorFallback?: ReactNode | ((error: unknown) => ReactNode);
+    id: string;
+    promise?: Promise<ReactNode>;
+    resolve?: () => Promise<ReactNode> | ReactNode;
+    fallback?: ReactNode;
+    timeoutMs?: number;
+};
+type FrameworkSuspenseSlotProps<T = unknown> = FrameworkSuspenseRenderProps<T> | FrameworkSuspenseNodeProps;
+type SuspenseSlotProps<T = unknown> = LegacySuspenseSlotProps | FrameworkSuspenseSlotProps<T>;
+export declare const SuspenseSlot: <T>(props: SuspenseSlotProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,5 @@
+export { Head } from '../Head';
+export { Image } from '../Image';
+export { JsonLd } from '../JsonLd';
+export { SuspenseSlot } from '../SuspenseSlot.browser';
+export { StreamSlot } from '../StreamSlot.browser';

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

@@ -0,0 +1,5 @@
+export { Head } from './Head';
+export { Image } from './Image';
+export { JsonLd } from './JsonLd';
+export { SuspenseSlot } from './SuspenseSlot';
+export { StreamSlot } from './StreamSlot';

package/dist/src/react/createIsland.browser.d.ts

@@ -0,0 +1,2 @@
+import type { IslandRegistry, IslandRegistryInput, TypedIslandRenderProps } from '../../types/island';
+export declare const createTypedIsland: <T extends IslandRegistryInput>(_registry: IslandRegistry<T>) => (props: TypedIslandRenderProps<T>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { IslandRegistry, IslandRegistryInput, TypedIslandRenderProps } from '../../types/island';
+export declare const createTypedIsland: <T extends IslandRegistryInput>(registry: IslandRegistry<T>) => (props: TypedIslandRenderProps<T>) => Promise<import("react/jsx-runtime").JSX.Element>;

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

@@ -0,0 +1,3 @@
+export { Breakpoint, Breakpoints } from '../../../types/mediaQuery';
+export { useIslandStore } from './useIslandStore';
+export { UserAgentProvider, useMediaQuery } from './useMediaQuery';

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

@@ -0,0 +1,3 @@
+import type { StoreApi } from 'zustand/vanilla';
+import { type IslandStoreState } from '../../client/islandStore';
+export declare const useIslandStore: <TState extends IslandStoreState, TSelected>(store: StoreApi<TState>, selector: (state: TState) => TSelected) => TSelected;

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

@@ -0,0 +1,7 @@
+import { Breakpoint, Breakpoints } from '../../../types/mediaQuery';
+export declare const UserAgentProvider: import("react").Provider<"other" | "bot" | "phone" | "tablet" | "tv" | "console" | "car" | "iot" | "desktop" | null>;
+export declare const useMediaQuery: (customBreakpoints?: Breakpoints) => {
+    breakpoint: string;
+    isSizeOrGreater: (target: Breakpoint) => boolean;
+    isSizeOrLess: (target: Breakpoint) => boolean;
+};

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

@@ -0,0 +1,4 @@
+export { handleReactPageRequest } from './pageHandler';
+export { Island } from './Island';
+export { createTypedIsland } from './createIsland';
+export { useIslandStore } from './hooks/useIslandStore';

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

@@ -0,0 +1,8 @@
+import { Fragment, jsx } from 'react/jsx-runtime';
+type JSXType = Parameters<typeof jsx>[0];
+type JSXKey = Parameters<typeof jsx>[2];
+type JSXProps = Parameters<typeof jsx>[1] & {
+    children?: unknown;
+};
+export { Fragment };
+export declare const jsxDEV: (type: JSXType, props: JSXProps, key?: JSXKey, _isStaticChildren?: boolean, _source?: unknown, _self?: unknown) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;

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

@@ -0,0 +1,25 @@
+import type { ComponentType as ReactComponent } from 'react';
+import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
+type ReactPageRenderOptions = StreamingSlotEnhancerOptions & {
+    collectStreamingSlots?: boolean;
+};
+export type ReactPageRequestInput<Props extends Record<string, unknown> = Record<never, never>> = ReactPageRenderOptions & {
+    Page: ReactComponent<Props>;
+    index: string;
+    /** The incoming Elysia request. When provided, the request's pathname
+     *  is auto-injected into props as `url` so the Page can wire
+     *  `<StaticRouter location={url}>` on the server without the caller
+     *  threading the URL by hand. User-supplied `props.url` (if present)
+     *  takes precedence — the auto-injection only fills in when missing. */
+    request?: Request;
+    /** Sitemap metadata for this route. Statically read from the handler
+     *  source at registration time, so only literal-object values are
+     *  honoured. */
+    sitemap?: import('../../types/sitemap').PageHandlerSitemapMetadata;
+} & (keyof Props extends never ? {
+    props?: NoInfer<Props>;
+} : {
+    props: NoInfer<Props>;
+});
+export declare const handleReactPageRequest: <Props extends Record<string, unknown> = Record<never, never>>(input: ReactPageRequestInput<Props>) => Promise<Response>;
+export {};

package/dist/src/react/router/UniversalRouter.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from 'react';
+export type UniversalRouterProps = {
+    /** The request URL to seed `<StaticRouter>` with on the server. Pages
+     *  typically forward `props.url` (auto-injected by handleReactPageRequest
+     *  from `request.url`). Ignored in the browser, where `<BrowserRouter>`
+     *  reads `window.location` directly. Defaults to '/'. */
+    url?: string;
+    children?: ReactNode;
+};
+/** SSR-safe wrapper around react-router that picks `<StaticRouter>` on the
+ *  server and `<BrowserRouter>` in the browser. Without it, every SPA page
+ *  has to write its own `typeof window === 'undefined'` branch and import
+ *  both routers — boilerplate that's the same in every page.
+ *
+ *  Usage:
+ *
+ *    import { UniversalRouter } from '@absolutejs/absolute/react/router';
+ *
+ *    export const MySpa = ({ url }: { url?: string }) => (
+ *      <html>
+ *        <Head />
+ *        <body>
+ *          <UniversalRouter url={url}>
+ *            <Routes>
+ *              <Route path="/foo" element={<Foo />} />
+ *            </Routes>
+ *          </UniversalRouter>
+ *        </body>
+ *      </html>
+ *    );
+ *
+ *  This component lives on its own `@absolutejs/absolute/react/router`
+ *  subpath rather than the main `@absolutejs/absolute/react` barrel so the
+ *  static `import 'react-router'` below only loads for consumers who
+ *  actually use the router — importing `Head`/`Image`/`Island` from
+ *  `@absolutejs/absolute/react` does not pull react-router into the bundle,
+ *  so projects that don't route aren't forced to install it.
+ *
+ *  `<BrowserRouter>` reads `window.history` at construction, so it throws
+ *  if instantiated on the server. The `typeof window` check has to live at
+ *  render time (not import time) because the module is loaded in both
+ *  environments. */
+export declare const UniversalRouter: ({ url, children }: UniversalRouterProps) => import("react").FunctionComponentElement<import("react-router").StaticRouterProps> | import("react").FunctionComponentElement<import("react-router").BrowserRouterProps>;

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

@@ -0,0 +1,2 @@
+export { UniversalRouter } from './UniversalRouter';
+export type { UniversalRouterProps } from './UniversalRouter';

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

@@ -0,0 +1,2 @@
+export { UniversalRouter } from './UniversalRouter';
+export type { UniversalRouterProps } from './UniversalRouter';

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

@@ -0,0 +1 @@
+export { handleReactPageRequest } from './pageHandler';

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

@@ -0,0 +1,7 @@
+import type { SpaHost } from '../utils/spaRouteTypes';
+/** Statically scan a React page-source directory for SPA hosts —
+ *  files that call `createBrowserRouter(routes, { basename })` from
+ *  `react-router-dom`. The first argument supplies the routes (inline
+ *  array or identifier reference), the second arg's `basename`
+ *  supplies the mount path. */
+export declare const analyzeReactSpaRoutes: (reactDirectory: string) => Promise<SpaHost[]>;

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

@@ -0,0 +1,4 @@
+export { createTypedIsland } from './createIsland.browser';
+export { resolveIslandHtml } from './resolveIslandHtml.browser';
+export { useIslandStore } from './islandStore';
+export declare const renderIsland: () => Promise<never>;

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

@@ -0,0 +1,2 @@
+import type { IslandRegistry, IslandRegistryInput, TypedIslandRenderProps } from '../../types/island';
+export declare const createTypedIsland: <T extends IslandRegistryInput>(_registry: IslandRegistry<T>) => (props: TypedIslandRenderProps<T>) => string;

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

@@ -0,0 +1,2 @@
+import type { IslandRegistry, IslandRegistryInput, TypedIslandRenderProps } from '../../types/island';
+export declare const createTypedIsland: <T extends IslandRegistryInput>(registry: IslandRegistry<T>) => (props: TypedIslandRenderProps<T>) => Promise<string>;

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

@@ -0,0 +1,6 @@
+export { handleSveltePageRequest } from './pageHandler';
+export { createTypedIsland } from './createIsland';
+export { useIslandStore } from './islandStore';
+export { renderIsland } from './renderIsland';
+export { resolveIslandHtml } from './resolveIslandHtml';
+export { renderToReadableStream } from './renderToReadableStream';

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

@@ -0,0 +1,5 @@
+import type { StoreApi } from 'zustand/vanilla';
+import { type IslandStoreState } from '../client/islandStore';
+export declare const useIslandStore: <TState extends IslandStoreState, TSelected>(store: StoreApi<TState>, selector: (state: TState) => TSelected) => {
+    subscribe(listener: (value: TSelected) => void): () => void;
+};

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

@@ -0,0 +1,4 @@
+export declare const lowerSvelteAwaitSlotSyntax: (source: string) => {
+    code: string;
+    transformed: boolean;
+};

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

@@ -0,0 +1,4 @@
+export declare const lowerSvelteIslandSyntax: (source: string, _mode?: "server" | "client") => {
+    code: string;
+    transformed: boolean;
+};

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

@@ -0,0 +1,28 @@
+import type { Component as SvelteComponent } from 'svelte';
+import type { SveltePropsOf } from '../../types/svelte';
+import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
+export type SveltePageRenderOptions = {
+    collectStreamingSlots?: boolean;
+    bodyContent?: string;
+    headContent?: string;
+} & StreamingSlotEnhancerOptions;
+type HasNoSvelteProps<Props> = [Props] extends [never] ? true : keyof Props extends never ? true : false;
+export type SveltePageRequestInput<Component extends SvelteComponent<never> = SvelteComponent<Record<never, never>>> = SveltePageRenderOptions & {
+    indexPath: string;
+    pagePath: string;
+    /** The incoming Elysia request. When provided, the request's pathname
+     *  is auto-injected into props as `url` so the page can pass it into
+     *  `<Router url={url}>` without the caller threading it by hand.
+     *  User-supplied `props.url` (if present) takes precedence. */
+    request?: Request;
+    /** Sitemap metadata for this route. Statically read from the handler
+     *  source at registration time, so only literal-object values are
+     *  honoured. */
+    sitemap?: import('../../types/sitemap').PageHandlerSitemapMetadata;
+} & (HasNoSvelteProps<SveltePropsOf<Component>> extends true ? {
+    props?: NoInfer<SveltePropsOf<Component>>;
+} : {
+    props: NoInfer<SveltePropsOf<Component>>;
+});
+export declare const handleSveltePageRequest: <Component extends SvelteComponent<never>>(input: SveltePageRequestInput<Component>) => Promise<Response>;
+export {};

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

@@ -0,0 +1,2 @@
+import type { RuntimeIslandRenderProps } from '../../types/island';
+export declare const renderIsland: (props: RuntimeIslandRenderProps) => Promise<string>;

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

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import type { Component, ComponentProps } from 'svelte';
+export type RenderPipeableOptions = {
+    bootstrapScriptContent?: string;
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+    nonce?: string;
+    onError?: (error: unknown) => void;
+    progressiveChunkSize?: number;
+    signal?: AbortSignal;
+};
+export declare const renderToPipeableStream: <Comp extends Component<Record<string, unknown>>>(component: Comp, props?: ComponentProps<Comp>, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError, progressiveChunkSize, signal }?: RenderPipeableOptions) => Readable;