@bleedingdev/modern-js-renderer-solid 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/types/router-binding/useBlocker.d.ts

@@ -0,0 +1,70 @@
+import type { HistoryAction } from '@tanstack/history';
+import type { AnyRoute, AnyRouter, ParseRoute, RegisteredRouter } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+import type { SolidNode } from './route.js';
+type ShouldBlockFnLocation<out TRouteId, out TFullPath, out TAllParams, out TFullSearchSchema> = {
+    routeId: TRouteId;
+    fullPath: TFullPath;
+    pathname: string;
+    params: TAllParams;
+    search: TFullSearchSchema;
+};
+type MakeShouldBlockFnLocationUnion<TRouter extends AnyRouter = RegisteredRouter, TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>> = TRoute extends any ? ShouldBlockFnLocation<TRoute['id'], TRoute['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema']> : never;
+type BlockerResolver<TRouter extends AnyRouter = RegisteredRouter> = {
+    status: 'blocked';
+    current: MakeShouldBlockFnLocationUnion<TRouter>;
+    next: MakeShouldBlockFnLocationUnion<TRouter>;
+    action: HistoryAction;
+    proceed: () => void;
+    reset: () => void;
+} | {
+    status: 'idle';
+    current: undefined;
+    next: undefined;
+    action: undefined;
+    proceed: undefined;
+    reset: undefined;
+};
+type ShouldBlockFnArgs<TRouter extends AnyRouter = RegisteredRouter> = {
+    current: MakeShouldBlockFnLocationUnion<TRouter>;
+    next: MakeShouldBlockFnLocationUnion<TRouter>;
+    action: HistoryAction;
+};
+export type ShouldBlockFn<TRouter extends AnyRouter = RegisteredRouter> = (args: ShouldBlockFnArgs<TRouter>) => boolean | Promise<boolean>;
+export type UseBlockerOpts<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean> = {
+    shouldBlockFn: ShouldBlockFn<TRouter>;
+    enableBeforeUnload?: boolean | (() => boolean);
+    disabled?: boolean;
+    withResolver?: TWithResolver;
+};
+type LegacyBlockerFn = () => Promise<any> | any;
+type LegacyBlockerOpts = {
+    blockerFn?: LegacyBlockerFn;
+    condition?: boolean | any;
+};
+export declare function useBlocker<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = false>(opts: UseBlockerOpts<TRouter, TWithResolver>): TWithResolver extends true ? Solid.Accessor<BlockerResolver<TRouter>> : void;
+/**
+ * @deprecated Use the shouldBlockFn property instead
+ */
+export declare function useBlocker(blockerFnOrOpts?: LegacyBlockerOpts): Solid.Accessor<BlockerResolver>;
+/**
+ * @deprecated Use the UseBlockerOpts object syntax instead
+ */
+export declare function useBlocker(blockerFn?: LegacyBlockerFn, condition?: boolean | any): Solid.Accessor<BlockerResolver>;
+interface BlockComponent {
+    <TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean>(opts: PromptProps<TRouter, TWithResolver>): SolidNode;
+    /**
+     *  @deprecated Use the UseBlockerOpts property instead
+     */
+    (opts: LegacyPromptProps): SolidNode;
+}
+export declare const Block: BlockComponent;
+type LegacyPromptProps = {
+    blockerFn?: LegacyBlockerFn;
+    condition?: boolean | any;
+    children?: SolidNode | ((params: BlockerResolver) => SolidNode);
+};
+type PromptProps<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean, TParams = TWithResolver extends true ? BlockerResolver<TRouter> : void> = UseBlockerOpts<TRouter, TWithResolver> & {
+    children?: SolidNode | ((params: TParams) => SolidNode);
+};
+export {};

package/dist/types/router-binding/useCanGoBack.d.ts

@@ -0,0 +1,2 @@
+import * as Solid from 'solid-js';
+export declare function useCanGoBack(): Solid.SourceAccessor<boolean>;

package/dist/types/router-binding/useLoaderData.d.ts

@@ -0,0 +1,8 @@
+import type { AnyRouter, RegisteredRouter, ResolveUseLoaderData, StrictOrFrom, UseLoaderDataResult } from '@tanstack/router-core';
+import type { Accessor } from 'solid-js';
+export interface UseLoaderDataBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> {
+    select?: (match: ResolveUseLoaderData<TRouter, TFrom, TStrict>) => TSelected;
+}
+export type UseLoaderDataOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseLoaderDataBaseOptions<TRouter, TFrom, TStrict, TSelected>;
+export type UseLoaderDataRoute<out TId> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseLoaderDataBaseOptions<TRouter, TId, true, TSelected>) => Accessor<UseLoaderDataResult<TRouter, TId, true, TSelected>>;
+export declare function useLoaderData<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TSelected = unknown>(opts: UseLoaderDataOptions<TRouter, TFrom, TStrict, TSelected>): Accessor<UseLoaderDataResult<TRouter, TFrom, TStrict, TSelected>>;

package/dist/types/router-binding/useLoaderDeps.d.ts

@@ -0,0 +1,8 @@
+import type { AnyRouter, RegisteredRouter, ResolveUseLoaderDeps, StrictOrFrom, UseLoaderDepsResult } from '@tanstack/router-core';
+import type { Accessor } from 'solid-js';
+export interface UseLoaderDepsBaseOptions<TRouter extends AnyRouter, TFrom, TSelected> {
+    select?: (deps: ResolveUseLoaderDeps<TRouter, TFrom>) => TSelected;
+}
+export type UseLoaderDepsOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TSelected> = StrictOrFrom<TRouter, TFrom> & UseLoaderDepsBaseOptions<TRouter, TFrom, TSelected>;
+export type UseLoaderDepsRoute<out TId> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseLoaderDepsBaseOptions<TRouter, TId, TSelected>) => Accessor<UseLoaderDepsResult<TRouter, TId, TSelected>>;
+export declare function useLoaderDeps<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TSelected = unknown>(opts: UseLoaderDepsOptions<TRouter, TFrom, TSelected>): Accessor<UseLoaderDepsResult<TRouter, TFrom, TSelected>>;

package/dist/types/router-binding/useLocation.d.ts

@@ -0,0 +1,7 @@
+import type { AnyRouter, RegisteredRouter, RouterState } from '@tanstack/router-core';
+import type { Accessor } from 'solid-js';
+export interface UseLocationBaseOptions<TRouter extends AnyRouter, TSelected> {
+    select?: (state: RouterState<TRouter['routeTree']>['location']) => TSelected;
+}
+export type UseLocationResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? RouterState<TRouter['routeTree']>['location'] : TSelected;
+export declare function useLocation<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseLocationBaseOptions<TRouter, TSelected>): Accessor<UseLocationResult<TRouter, TSelected>>;

package/dist/types/router-binding/useMatch.d.ts

@@ -0,0 +1,10 @@
+import type { AnyRouter, MakeRouteMatch, MakeRouteMatchUnion, RegisteredRouter, StrictOrFrom, ThrowConstraint, ThrowOrOptional } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+export interface UseMatchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (match: MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+export type UseMatchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseMatchBaseOptions<TRouter, TFrom, true, true, TSelected>) => Solid.Accessor<UseMatchResult<TRouter, TFrom, true, TSelected>>;
+export type UseMatchOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseMatchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+export type UseMatchResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? TStrict extends true ? MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict> : MakeRouteMatchUnion<TRouter> : TSelected;
+export declare function useMatch<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: UseMatchOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Solid.Accessor<ThrowOrOptional<UseMatchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;

package/dist/types/router-binding/useNavigate.d.ts

@@ -0,0 +1,5 @@
+import type { AnyRouter, FromPathOption, NavigateOptions, RegisteredRouter, UseNavigateResult } from '@tanstack/router-core';
+export declare function useNavigate<TRouter extends AnyRouter = RegisteredRouter, TDefaultFrom extends string = string>(_defaultOpts?: {
+    from?: FromPathOption<TRouter, TDefaultFrom>;
+}): UseNavigateResult<TDefaultFrom>;
+export declare function Navigate<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): null;

package/dist/types/router-binding/useParams.d.ts

@@ -0,0 +1,9 @@
+import type { AnyRouter, RegisteredRouter, ResolveUseParams, StrictOrFrom, ThrowConstraint, ThrowOrOptional, UseParamsResult } from '@tanstack/router-core';
+import type { Accessor } from 'solid-js';
+export interface UseParamsBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (params: ResolveUseParams<TRouter, TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+export type UseParamsOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseParamsBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+export type UseParamsRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseParamsBaseOptions<TRouter, TFrom, true, true, TSelected>) => Accessor<UseParamsResult<TRouter, TFrom, true, TSelected>>;
+export declare function useParams<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: UseParamsOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Accessor<ThrowOrOptional<UseParamsResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;

package/dist/types/router-binding/useRouteContext.d.ts

@@ -0,0 +1,4 @@
+import type { AnyRouter, RegisteredRouter, UseRouteContextBaseOptions, UseRouteContextOptions, UseRouteContextResult } from '@tanstack/router-core';
+import type { Accessor } from 'solid-js';
+export type UseRouteContextRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseRouteContextBaseOptions<TRouter, TFrom, true, TSelected>) => Accessor<UseRouteContextResult<TRouter, TFrom, true, TSelected>>;
+export declare function useRouteContext<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TSelected = unknown>(opts: UseRouteContextOptions<TRouter, TFrom, TStrict, TSelected>): Accessor<UseRouteContextResult<TRouter, TFrom, TStrict, TSelected>>;

package/dist/types/router-binding/useRouter.d.ts

@@ -0,0 +1,4 @@
+import type { AnyRouter, RegisteredRouter } from '@tanstack/router-core';
+export declare function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {
+    warn?: boolean;
+}): TRouter;

package/dist/types/router-binding/useRouterState.d.ts

@@ -0,0 +1,8 @@
+import type { AnyRouter, RegisteredRouter, RouterState } from '@tanstack/router-core';
+import type { Accessor } from 'solid-js';
+export type UseRouterStateOptions<TRouter extends AnyRouter, TSelected> = {
+    router?: TRouter;
+    select?: (state: RouterState<TRouter['routeTree']>) => TSelected;
+};
+export type UseRouterStateResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? RouterState<TRouter['routeTree']> : TSelected;
+export declare function useRouterState<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseRouterStateOptions<TRouter, TSelected>): Accessor<UseRouterStateResult<TRouter, TSelected>>;

package/dist/types/router-binding/useSearch.d.ts

@@ -0,0 +1,9 @@
+import type { AnyRouter, RegisteredRouter, ResolveUseSearch, StrictOrFrom, ThrowConstraint, ThrowOrOptional, UseSearchResult } from '@tanstack/router-core';
+import type { Accessor } from 'solid-js';
+export interface UseSearchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (state: ResolveUseSearch<TRouter, TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+export type UseSearchOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseSearchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+export type UseSearchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseSearchBaseOptions<TRouter, TFrom, true, true, TSelected>) => Accessor<UseSearchResult<TRouter, TFrom, true, TSelected>>;
+export declare function useSearch<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: UseSearchOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Accessor<ThrowOrOptional<UseSearchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;

package/dist/types/router-binding/utils.d.ts

@@ -0,0 +1,25 @@
+import * as Solid from 'solid-js';
+/**
+ * React hook to wrap `IntersectionObserver`.
+ *
+ * This hook will create an `IntersectionObserver` and observe the ref passed to it.
+ *
+ * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.
+ *
+ * @param ref - The ref to observe
+ * @param callback - The callback to call when the intersection changes
+ * @param disabled - Whether observation is disabled
+ * @returns The IntersectionObserver instance
+ * @example
+ * ```tsx
+ * const MyComponent = () => {
+ * const ref = React.useRef<HTMLDivElement>(null)
+ * useIntersectionObserver(
+ *  ref,
+ *  (entry) => { doSomething(entry) },
+ *  false
+ * )
+ * return <div ref={ref} />
+ * ```
+ */
+export declare function useIntersectionObserver<T extends Element>(ref: Solid.Accessor<T | null>, callback: (entry?: IntersectionObserverEntry) => void, disabled: Solid.Accessor<boolean>): Solid.Accessor<IntersectionObserver | null>;

package/dist/types/router.d.ts

@@ -0,0 +1,31 @@
+import type { DataOutcome, FileSystemRouteIR, PublicDataOutcome } from '@modern-js/renderer-core/data';
+import type { FileSystemRouteOptions } from '@modern-js/renderer-core/router';
+import type { AnyRoute, AnyRouter, ErrorRouteComponent, NotFoundRouteComponent, RouteComponent } from './router-binding/index.js';
+export type { DataHandler, DataHandlerInput, DataOutcome, DecodedDataOutcome, PublicDataOutcome, } from '@modern-js/renderer-core/data';
+export type { FileSystemDataModule, FileSystemRouteOptions, } from '@modern-js/renderer-core/router';
+export { matchApplicationRouteIds, matchApplicationRoutes, RouteDataError, selectApplicationDataRoute, } from '@modern-js/renderer-core/router';
+export type { ActionFormProps, RouteAction, RouteActionOptions, } from './actions.js';
+export { ActionForm, createRouteAction, RouteActionError, useRouteAction, } from './actions.js';
+export { ApplicationRouter } from './application-router.js';
+export { createApplicationRouter } from './route-completion.js';
+export * from './router-binding/index.js';
+export interface FileSystemRouteModule {
+    component?: RouteComponent;
+    pendingComponent?: RouteComponent;
+    errorComponent?: ErrorRouteComponent;
+    notFoundComponent?: NotFoundRouteComponent;
+    head?: AnyRoute['options']['head'];
+    /** Explicit returned context becomes immutable public native route context. */
+    beforeLoad?: AnyRoute['options']['beforeLoad'];
+    /** Native synchronous context contributions are checked before composition. */
+    context?: AnyRoute['options']['context'];
+    validateSearch?: (search: Record<string, unknown>) => Record<string, unknown>;
+}
+/** Resolve location through the native router before committing HTTP headers. */
+export declare function resolveApplicationRedirect(router: AnyRouter): Response | undefined;
+/** The native server load resolves status independently from rendered UI. */
+export declare function getApplicationStatus(router: AnyRouter): number;
+/** Throw outcomes into the native Solid redirect, not-found and error boundaries. */
+export declare function resolveRouteData(routeId: string, outcome: DataOutcome | PublicDataOutcome, project?: (value: unknown) => unknown): unknown;
+/** Project route structure into native factories without matching any URL. */
+export declare function createFileSystemRouteTree<Context = unknown>(routes: readonly FileSystemRouteIR[], modules: Readonly<Record<string, FileSystemRouteModule>>, options?: FileSystemRouteOptions<Context>): AnyRoute;

package/dist/types/server.d.ts

@@ -0,0 +1,47 @@
+import { type DocumentAsset, type DocumentInlineData } from '@modern-js/renderer-core/document';
+import type { NativeFederationBinding } from '@modern-js/renderer-core/federation';
+import { type RequestSession } from '@modern-js/renderer-core/session';
+import { type JSX, renderToStream } from '@solidjs/web';
+type NativeStreamOptions = NonNullable<Parameters<typeof renderToStream>[1]>;
+/** Establish Solid's native request scope before loaders and response dispatch. */
+export declare function runApplicationRequest<Bindings extends object, Result>(session: RequestSession<Bindings>, callback: () => Result): Promise<Awaited<Result>>;
+/** Fold Solid's native response metadata before the one session body commits. */
+export declare function respondApplication<Bindings extends object>(session: RequestSession<Bindings>, body: ReadableStream<Uint8Array> | null): Response;
+/** Adopt an explicit data or redirect Response without replacing its outcome. */
+export declare function respondApplicationResponse<Bindings extends object>(session: RequestSession<Bindings>, response: Response): Response;
+/** Solid owns hydration, lazy module assets and head placement in its document. */
+export type SolidDocumentOptions = Pick<NativeStreamOptions, 'renderId' | 'nonce' | 'manifest' | 'onHead'>;
+export interface SolidRenderOptions<Bindings extends object = object> {
+    readonly session: RequestSession<Bindings>;
+    readonly view: () => JSX.Element;
+    readonly document?: SolidDocumentOptions;
+    /** Return Solid's native public error mapping, if one is required. */
+    readonly onError?: NativeStreamOptions['onError'];
+    /** This server compilation's native Module Federation runtime. */
+    readonly federation?: NativeFederationBinding;
+}
+export type { DocumentInlineData };
+export interface SolidApplicationDocumentOptions extends SolidDocumentOptions {
+    readonly rootId?: string;
+    readonly lang?: string;
+    readonly assets?: readonly DocumentAsset[];
+    /** Placed in the head, after the renderer bootstrap and before modules. */
+    readonly inlineData?: readonly DocumentInlineData[];
+}
+export interface SolidDocumentRenderOptions<Bindings extends object = object> extends Omit<SolidRenderOptions<Bindings>, 'document'> {
+    readonly document?: SolidApplicationDocumentOptions;
+}
+/**
+ * Render a prepared Node document through Solid's one readable consumer.
+ * The caller resolves blocking route/data HTTP outcomes before calling this.
+ * Like Solid's own SSR response, the HTTP head commits when the shell
+ * completes, so status, headers and redirects declared before the shell apply
+ * and a shell-time failure rejects before any head commits.
+ * A contained native fallback can finish, but is never a successful cache entry.
+ * A deferred uncontained failure cancels delivery without changing sent headers.
+ */
+export declare function renderApplication<Bindings extends object>(options: SolidRenderOptions<Bindings>): Promise<Response>;
+/** Construct the native document used by generated and hand-authored entries. */
+export declare function renderDocumentApplication<Bindings extends object>(options: SolidDocumentRenderOptions<Bindings>): Promise<Response>;
+/** CSR delivers an empty mount region and never evaluates an SSR application. */
+export declare function renderCSRDocument<Bindings extends object>(options: Pick<SolidDocumentRenderOptions<Bindings>, 'session' | 'document'>): Response;

package/package.json

@@ -1,11 +1,125 @@
 {
   "name": "@bleedingdev/modern-js-renderer-solid",
-  "version": "0.0.0-bootstrap",
-  "description": "Package-name reservation. Release versions publish through GitHub Trusted Publishing.",
+  "version": "3.9.3-ultramodern.1",
+  "description": "UltraModern native Solid 2 application runtime.",
   "license": "MIT",
+  "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git"
+    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git",
+    "directory": "packages/runtime/renderer-solid"
   },
-  "deprecated": "Package-name reservation only. Install a release version published through GitHub Trusted Publishing."
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/esm-node/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/esm-node/index.js"
+    },
+    "./client": {
+      "types": "./dist/types/client.d.ts",
+      "default": "./dist/esm/client.js"
+    },
+    "./router": {
+      "types": "./dist/types/router.d.ts",
+      "worker": "./dist/esm-node/router.js",
+      "node": "./dist/esm-node/router.js",
+      "default": "./dist/esm/router.js"
+    },
+    "./server": {
+      "types": "./dist/types/server.d.ts",
+      "default": "./dist/esm-node/server.js"
+    },
+    "./federation": {
+      "types": "./dist/types/federation.d.ts",
+      "node": "./dist/esm-node/federation.js",
+      "default": "./dist/esm/federation.js"
+    },
+    "./manifest": {
+      "types": "./dist/types/manifest.d.ts",
+      "default": "./dist/esm-node/manifest.js"
+    },
+    "./i18n": {
+      "types": "./dist/types/i18n/index.d.ts",
+      "node": "./dist/esm-node/i18n/index.js",
+      "default": "./dist/esm/i18n/index.js"
+    },
+    "./entry-client": {
+      "types": "./dist/types/entry-client.d.ts",
+      "default": "./dist/esm/entry-client.js"
+    },
+    "./entry-server": {
+      "types": "./dist/types/entry-server.d.ts",
+      "default": "./dist/esm-node/entry-server.js"
+    },
+    "./plugin": {
+      "types": "./dist/types/plugin/index.d.ts",
+      "default": "./dist/esm-node/plugin/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=26.10.0"
+  },
+  "dependencies": {
+    "@babel/core": "7.29.7",
+    "@jridgewell/remapping": "2.3.5",
+    "@modern-js/renderer-core": "npm:@bleedingdev/modern-js-renderer-core@3.9.3-ultramodern.1",
+    "@solidjs/signals": "2.0.0-rc.13",
+    "@solidjs/web": "2.0.0-rc.13",
+    "@tanstack/history": "1.162.4",
+    "@tanstack/router-core": "1.171.34",
+    "isbot": "5.2.2",
+    "seroval": "1.6.8",
+    "seroval-plugins": "1.6.8",
+    "solid-js": "2.0.0-rc.13"
+  },
+  "peerDependencies": {
+    "@modern-js/i18n-runtime-extensions": "3.9.3-ultramodern.1",
+    "@rsbuild/core": "2.2.11",
+    "@solidjs/compiler": "2.0.0-rc.13",
+    "i18next": ">=25.7.4"
+  },
+  "peerDependenciesMeta": {
+    "@modern-js/i18n-runtime-extensions": {
+      "optional": true
+    },
+    "@rsbuild/core": {
+      "optional": true
+    },
+    "@solidjs/compiler": {
+      "optional": true
+    },
+    "i18next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.3-ultramodern.1",
+    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.3-ultramodern.1",
+    "@rsbuild/core": "2.2.11",
+    "@rslib/core": "1.0.3",
+    "@scripts/rstest-config": "2.66.0",
+    "@solidjs/compiler": "2.0.0-rc.13",
+    "@types/node": "^26.6.3"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "test": "rstest"
+  },
+  "homepage": "https://github.com/ultramodernjs/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/ultramodernjs/ultramodern.js/issues"
+  },
+  "ultramodern": {
+    "sourceName": "@modern-js/renderer-solid"
+  }
 }