@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.1

package/dist/types/federation.d.ts

@@ -0,0 +1,18 @@
+import { type ComponentBody, type OctaneNode } from 'octane';
+/** The native component shape exposed by a same-renderer Octane remote. */
+export interface FederatedModule<P extends object> {
+    readonly default: ComponentBody<P>;
+}
+export interface FederatedComponentOptions {
+    /** Native content shown while loading, or after a failed server load. */
+    readonly fallback?: () => OctaneNode;
+    /** A positive load limit; the server defaults to 3000ms. */
+    readonly timeout?: number;
+}
+/**
+ * Render a native Octane remote by its `remote/Expose` id or a browser loader.
+ * Native Suspense owns server fallbacks, streamed styles and hydration adoption;
+ * browser failures reach the nearest native ErrorBoundary. A loader function is
+ * browser-only; use an id to render through the host's server federation runtime.
+ */
+export declare function federatedComponent<P extends object = Record<string, never>>(remote: string | (() => Promise<FederatedModule<P>>), options?: FederatedComponentOptions): ComponentBody<P>;

package/dist/types/i18n/I18nProvider.d.ts

@@ -0,0 +1,8 @@
+import type { I18nContextValue } from './types';
+export interface I18nProviderProps extends Omit<I18nContextValue, 'language'> {
+    children?: unknown;
+}
+export declare function I18nProvider(props: I18nProviderProps): import("octane").ElementDescriptor<{
+    value: I18nContextValue;
+    children: unknown;
+}>;

package/dist/types/i18n/LocalizedLink.d.ts

@@ -0,0 +1,41 @@
+import { type OctaneNode } from 'octane';
+import { type LinkComponentProps } from '../router';
+export interface LocalizedLinkProps {
+    /** A canonical, language-agnostic target, e.g. `/products/red-shoe`. */
+    to: string;
+    /** Localize for a specific language instead of the current one. */
+    language?: string;
+    children?: unknown;
+    class?: string;
+    activeProps?: LinkComponentProps<'a'>['activeProps'];
+    inactiveProps?: LinkComponentProps<'a'>['inactiveProps'];
+    activeOptions?: LinkComponentProps<'a'>['activeOptions'];
+    replace?: boolean;
+    preload?: LinkComponentProps<'a'>['preload'];
+}
+/**
+ * A thin wrapper over the native Octane router `Link`
+ * (`@octanejs/tanstack-router`'s precompiled `Link.tsrx`) that localizes a
+ * canonical `to` for the current (or an explicit) language before handing it
+ * to the real link — the same contract as `@modern-js/plugin-i18n`'s React
+ * `Link`. It resolves the href itself via the shared pathname helpers, so it
+ * works with or without the router's i18n `rewrite`. Every link, including
+ * one to another language, is the native `Link`: navigation, preloading and
+ * active state stay with the router.
+ *
+ * Under the i18n `rewrite` the router matches canonical paths and localizes
+ * outgoing locations to the current language, so a link to another language
+ * routes to the canonical `to` and publishes the target language's URL as a
+ * route mask (the rewrite keeps a mask's explicit language). The entry's
+ * router language synchronization (`syncWithRouter`) switches the i18next
+ * instance from the navigated URL, as it does for history navigation.
+ *
+ * No JSX: built with `createElement`, matching this package's existing
+ * style (see `src/routes.ts`).
+ */
+export declare function LocalizedLink(props: LocalizedLinkProps): OctaneNode;
+/**
+ * Language-invariant active check: `to="/products"` is active whether the
+ * current location is `/en/products` or `/produkty` under a mapped locale.
+ */
+export declare function useIsLocalizedActive(canonicalTarget: string): boolean;

package/dist/types/i18n/context.d.ts

@@ -0,0 +1,9 @@
+import type { I18nContextValue } from './types';
+export type { I18nContextValue, I18nInstanceLike } from './types';
+/**
+ * Octane's `createContext<T>(defaultValue: T)` requires a default (unlike
+ * Solid 2's default-less form), so a missing provider is detected by
+ * checking for `null` in `useI18n`/`useIsLocalizedActive` instead — the same
+ * guard shape `@modern-js/plugin-i18n`'s React `ModernI18nContext` uses.
+ */
+export declare const I18nContext: import("octane").Context<I18nContextValue | null>;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,9 @@
+export { createRequestLanguageRedirect, detectRequestLanguage, languageFromPathname, type RequestLanguageDetection, type ResolvedRequestLanguage, type ResolveRequestLanguageOptions, resolveRequestLanguage, } from '@modern-js/i18n-runtime-extensions/request-language';
+export { createI18nSsrHandoffInlineData, I18N_SSR_HANDOFF_ELEMENT_ID, type I18nSsrHandoffPayload, type I18nSsrHandoffResources, readI18nSsrHandoff, } from '@modern-js/i18n-runtime-extensions/ssrLanguageHandoff';
+export { type CreateI18nUrlRewriteOptions, createI18nUrlRewrite, type I18nLocationRewrite, } from '@modern-js/i18n-runtime-extensions/urlRewrite';
+export { I18nContext } from './context';
+export { I18nProvider, type I18nProviderProps } from './I18nProvider';
+export { LocalizedLink, type LocalizedLinkProps, useIsLocalizedActive, } from './LocalizedLink';
+export { type OctaneLatestLanguageSyncOptions, useLatestLanguageSync, } from './languageSync';
+export type { I18nContextValue, I18nInstanceLike } from './types';
+export { type UseI18nReturn, useI18n } from './useI18n';

package/dist/types/i18n/languageSync.d.ts

@@ -0,0 +1,26 @@
+import { type LanguageSyncFailure, type LanguageSyncPolicy } from '@modern-js/i18n-runtime-extensions/language-sync/controller';
+export interface OctaneLatestLanguageSyncOptions<TTarget extends object> {
+    changeLanguage: (target: TTarget, language: string) => PromiseLike<unknown> | unknown;
+    commitLanguage: (target: TTarget, language: string) => void;
+    desiredLanguage?: string;
+    enabled?: boolean;
+    policy?: LanguageSyncPolicy;
+    readLanguage?: (target: TTarget) => string | undefined;
+    reportFailure?: (failure: LanguageSyncFailure) => void;
+    target?: TTarget;
+}
+/**
+ * Octane binding over the fork's renderer-neutral `Coordinator`/`Binding`
+ * pair (`@modern-js/i18n-runtime-extensions`'s `createLatestLanguageSyncBinding`):
+ * the same "latest intent wins, retry with backoff, report terminal failure"
+ * policy the React `useLatestLanguageSync` hook drives.
+ *
+ * Octane's own hook API (`useState`/`useEffect`/`useContext`/
+ * `useSyncExternalStore`, confirmed in `node_modules/octane/dist/runtime.d.ts`)
+ * is React-shaped, so this binding mirrors
+ * `i18n-extensions/src/language-sync/react.ts`'s `useLatestLanguageSync`
+ * directly — the Solid binding needed a `createEffect`/`onCleanup`
+ * reshaping for Solid 2's different (compute/effect-split, no
+ * `useEffect`-style dependency arrays) reactivity model; Octane does not.
+ */
+export declare const useLatestLanguageSync: <TTarget extends object>({ changeLanguage, commitLanguage, desiredLanguage, enabled, policy, readLanguage, reportFailure, target, }: OctaneLatestLanguageSyncOptions<TTarget>) => ((language: string) => void);

package/dist/types/i18n/types.d.ts

@@ -0,0 +1,34 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+/**
+ * The slice of an i18next-shaped instance this binding needs. Deliberately
+ * not `@modern-js/plugin-i18n`'s `I18nInstance`: that type is intentionally
+ * narrowed (no index signature, non-overloaded methods — see plugin-i18n's
+ * fork notes) and, more importantly, the plugin package's peer dependencies
+ * require React/ReactDOM, which an Octane-only application must never need
+ * to install. `on`/`off` are real i18next `EventEmitter` methods this
+ * interface adds back for the reactive `languageChanged` subscription.
+ */
+export interface I18nInstanceLike {
+    language: string;
+    t(key: string | string[], options?: Record<string, unknown>): string;
+    changeLanguage?(lng?: string): Promise<unknown> | unknown;
+    on?(event: 'languageChanged', callback: (lng: string) => void): void;
+    off?(event: 'languageChanged', callback: (lng: string) => void): void;
+    /** SSR per-request isolation: the server clones a base instance per request. */
+    cloneInstance?(options?: Record<string, unknown>): I18nInstanceLike;
+}
+export interface I18nContextValue {
+    /** Per-request instance. Never a module-level singleton. */
+    instance: I18nInstanceLike;
+    languages: readonly string[];
+    localisedUrls?: LocalisedUrlsOption;
+    /**
+     * Reactive current language, owned by `I18nProvider`'s own `useState` +
+     * one `languageChanged` subscription. `instance.language` is a plain
+     * mutable field, not itself reactive — Octane's context only re-renders
+     * consumers when the Provider commits a *new* `value` object (its
+     * `$$version` bumps), so every consumer reads this field off the context
+     * value instead of reaching into `instance.language` directly.
+     */
+    language: string;
+}

package/dist/types/i18n/useI18n.d.ts

@@ -0,0 +1,21 @@
+import type { I18nInstanceLike } from './types';
+export interface UseI18nReturn {
+    t: I18nInstanceLike['t'];
+    /** Current language. Re-renders the calling component on `languageChanged`. */
+    language: string;
+    languages: readonly string[];
+    /** The raw per-request instance, for advanced use (namespaces, `exists`, ...). */
+    instance: I18nInstanceLike;
+    /**
+     * Switches the i18next instance's language. With a router, also navigates to
+     * the localized path so the URL and active language stay aligned.
+     */
+    changeLanguage: (language: string) => Promise<void>;
+}
+/**
+ * Must render under `I18nProvider`; throws rather than silently reading a
+ * fallback instance when no provider is mounted (Octane's `createContext`
+ * requires a default value, so `I18nContext`'s default is `null` and this
+ * hook turns that into a loud error instead of a shared singleton).
+ */
+export declare function useI18n(): UseI18nReturn;

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export type { RendererIdentity } from '@modern-js/renderer-core/identity';
+export type { OctaneDocumentBootstrap } from './bootstrap';
+export declare const OCTANE_RUNTIME_PROFILE: Readonly<{
+    renderer: "octane";
+    runtime: "0.7.1+ultramodern.1331985ea3b0";
+    router: "0.1.60+ultramodern.0b9f76ee3003";
+    routerCore: "1.171.15";
+    history: "1.162.0";
+}>;

package/dist/types/manifest.d.ts

@@ -0,0 +1,34 @@
+import type { NativeCompilerArtifacts } from '@modern-js/renderer-core/adapter';
+import { type RendererIdentity } from '@modern-js/renderer-core/identity';
+export declare const OCTANE_RUNTIME_VERSION = "0.7.1+ultramodern.1331985ea3b0";
+export declare const OCTANE_COMPILER_VERSION = "0.1.55";
+export interface OctaneCompiledSource {
+    readonly resource: string;
+    readonly canonicalId: string;
+    readonly moduleId: string | number;
+    readonly transformKind: 'compile' | 'slots' | 'client-only-stub';
+    readonly emittedSourceSha256: string;
+    readonly assets: readonly string[];
+}
+export interface OctaneModuleManifest {
+    readonly schemaVersion: 1;
+    readonly renderer: 'octane';
+    readonly runtimeVersion: typeof OCTANE_RUNTIME_VERSION;
+    readonly compilerVersion: typeof OCTANE_COMPILER_VERSION;
+    readonly rendererIdentity: Readonly<RendererIdentity>;
+    readonly nativeHydrationBuildId: string;
+    readonly sourceModules: readonly OctaneCompiledSource[];
+    readonly assets: readonly {
+        readonly file: string;
+        readonly sha256: string;
+    }[];
+}
+export declare function octaneModuleManifestFileName(entryName: string): string;
+/** Validates completed native bytes separately from the source/profile build. */
+export declare function validateOctaneModuleManifest(value: unknown, expectedIdentity: RendererIdentity, expectedNativeHydrationBuildId?: string): OctaneModuleManifest;
+/**
+ * The compiler artifact ABI. It lives in this runtime module, not in the
+ * build-only `./plugin`, because the production server validates manifests
+ * with it and deployments trace it from there.
+ */
+export declare const compilerArtifacts: NativeCompilerArtifacts;

package/dist/types/plugin/compiler-manifest.d.cts

@@ -0,0 +1,10 @@
+declare const _exports: {
+    OctaneCompilerManifestPlugin: typeof OctaneCompilerManifestPlugin;
+};
+export = _exports;
+/** The released native compiler remains responsible for every transformation. */
+declare class OctaneCompilerManifestPlugin {
+    options: any;
+    constructor(options: any);
+    apply(compiler: any): void;
+}

package/dist/types/plugin/compiler.d.ts

@@ -0,0 +1,5 @@
+import type { NativeRendererCompilerOptions } from '@modern-js/renderer-core/adapter';
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare function pluginSourceDirectory(): string;
+/** Octane owns native compilation; UltraModern retains the application host. */
+export declare function createOctaneCompilerPlugin(options: NativeRendererCompilerOptions): RsbuildPlugin;

package/dist/types/plugin/create.d.ts

@@ -0,0 +1,23 @@
+export type OctaneAppSourceOptions = {
+    appId: string;
+    title: string;
+    entryName?: string;
+    appRole?: 'shell' | 'vertical';
+    sourceExtension: '.tsx' | '.tsrx';
+    jsxImportSource: string;
+    capabilities: {
+        ssr: boolean;
+        federation: boolean;
+    };
+};
+export type OctaneAppSourceArtifact = {
+    path: string;
+    content: string;
+};
+export type OctaneAppSources = {
+    sourceExtension: '.tsx';
+    jsxImportSource: 'octane';
+    artifacts: OctaneAppSourceArtifact[];
+};
+/** The renderer adapter owns entry generation, the document and hydration. */
+export declare function generateOctaneAppSources(options: OctaneAppSourceOptions): OctaneAppSources;

package/dist/types/plugin/index.d.ts

@@ -0,0 +1,3 @@
+import { type NativeRendererAdapter } from '@modern-js/renderer-core/adapter';
+/** The build-side Octane renderer adapter UltraModern loads for `renderer: 'octane'`. */
+export declare const rendererAdapter: NativeRendererAdapter<'octane'>;

package/dist/types/plugin/profile.d.ts

@@ -0,0 +1,2 @@
+import type { RendererBuildProfile } from '@modern-js/renderer-core/adapter';
+export declare const octaneProfile: RendererBuildProfile<'octane'>;

package/dist/types/plugin/source.d.ts

@@ -0,0 +1 @@
+export declare function assertOctaneEntrySource(source: string | false | undefined): Promise<void>;

package/dist/types/plugin/svg-component-template.d.cts

@@ -0,0 +1,6 @@
+export = _exports;
+declare function _exports({ attributes, markup, origin, }: {
+    attributes: any;
+    markup: any;
+    origin: any;
+}): string;

package/dist/types/router-client.d.ts

@@ -0,0 +1,12 @@
+import { type AnyRouter } from '@octanejs/tanstack-router';
+export interface OctaneRouterHydrationOptions {
+    signal?: AbortSignal;
+}
+/** Restore native SSR matches before Octane adopts the server's route ranges. */
+export declare function prepareOctaneRouterHydration(router: AnyRouter, options?: OctaneRouterHydrationOptions): Promise<void>;
+/** Adopt the native provider's ranges inside the admitted fragment host. */
+export declare function OctaneRouterRoot({ router }: {
+    router: AnyRouter;
+}): import("octane").ElementDescriptor<{
+    router: AnyRouter;
+}>;

package/dist/types/router-handler.d.ts

@@ -0,0 +1,13 @@
+import type { RequestSession } from '@modern-js/renderer-core/session';
+import { type AnyRouter } from '@octanejs/tanstack-router';
+import { attachRouterServerSsrUtils, type RequestHandler } from '@octanejs/tanstack-router/ssr/server';
+import { type OctaneRouterSerializationOptions } from './router-server-snapshot';
+export interface OctaneRequestHandlerOptions<TRouter extends AnyRouter> {
+    createRouter(): TRouter;
+    request: Request;
+    session: RequestSession;
+    getRouterManifest?: () => Parameters<typeof attachRouterServerSsrUtils>[0]['manifest'] | Promise<Parameters<typeof attachRouterServerSsrUtils>[0]['manifest']>;
+    serialization?: OctaneRouterSerializationOptions;
+}
+/** Resolve native routes and HTTP disposition before the native document serializer. */
+export declare function createOctaneRequestHandler<TRouter extends AnyRouter>({ createRouter, request, session, getRouterManifest, serialization, }: OctaneRequestHandlerOptions<TRouter>): RequestHandler<TRouter>;

package/dist/types/router-injection.d.ts

@@ -0,0 +1,8 @@
+import type { RequestSession } from '@modern-js/renderer-core/session';
+import type { AnyRouter } from '@octanejs/tanstack-router';
+import type { StreamInjectionSource } from 'octane/server';
+export interface OctaneRouterInjectionOptions {
+    serializationTimeoutMs?: number;
+}
+/** Couple native router serialization to the response's single stream owner. */
+export declare function createOctaneRouterInjection(router: AnyRouter, session: RequestSession, options?: OctaneRouterInjectionOptions): StreamInjectionSource;

package/dist/types/router-server-cleanup.d.ts

@@ -0,0 +1,3 @@
+import type { AnyRouter } from '@octanejs/tanstack-router';
+/** The request handler, serializer and renderer share one native SSR owner. */
+export declare function cleanupOctaneRouterSSR(router: AnyRouter): void;

package/dist/types/router-server-snapshot.d.ts

@@ -0,0 +1,15 @@
+import { type RequestSession } from '@modern-js/renderer-core/session';
+import { type AnyRouter } from '@octanejs/tanstack-router';
+export interface OctaneRouterSerializationOptions {
+    readonly production?: boolean;
+    /** Request-private records that are structurally ordinary JavaScript objects. */
+    readonly forbiddenValues?: readonly object[];
+}
+export interface OctaneRouterSerializationGuard {
+    /** Call immediately before native dehydrateMatch reads the internal matches. */
+    assertMatches(): void;
+    /** Native Seroval swallows errors; call after dehydrate and before responding. */
+    assertActive(): void;
+}
+/** Project the fresh native outer record before Seroval walks any application value. */
+export declare function prepareOctaneRouterSerialization(router: AnyRouter, session: RequestSession, options?: OctaneRouterSerializationOptions): OctaneRouterSerializationGuard;

package/dist/types/router-server.d.ts

@@ -0,0 +1,13 @@
+import { type AnyRouter } from '@octanejs/tanstack-router';
+import { type ServerRenderNode } from 'octane/server';
+export * from '@octanejs/tanstack-router/ssr/server';
+export type { OctaneRequestHandlerOptions } from './router-handler';
+export { createOctaneRequestHandler } from './router-handler';
+export type { OctaneRouterInjectionOptions } from './router-injection';
+export { createOctaneRouterInjection } from './router-injection';
+export type { OctaneRouterSerializationGuard, OctaneRouterSerializationOptions, } from './router-server-snapshot';
+export { prepareOctaneRouterSerialization } from './router-server-snapshot';
+/** Render the native provider using the released Start server root contract. */
+export declare function OctaneRouterServer({ router, }: {
+    router: AnyRouter;
+}): ServerRenderNode;

package/dist/types/router-snapshot.d.ts

@@ -0,0 +1,14 @@
+import { DataProtocolError } from '@modern-js/renderer-core/data';
+import { type AnySerializationAdapter } from '@octanejs/tanstack-router';
+export declare const ADAPTER_KEY = "ultramodern.octane-public-snapshot.v1";
+export declare const ROUTE_ERROR_KIND = "ultramodern-route-error";
+export declare const NATIVE_ERROR_KIND = "ultramodern-native-error";
+export declare const NATIVE_ROOT_FIELDS: Set<string>;
+export declare const MATCH_FIELDS: Set<string>;
+export declare function invalid(message: string): DataProtocolError;
+export declare function descriptors(value: object, allowed?: ReadonlySet<string>, allowLazyStack?: boolean): Record<string, PropertyDescriptor>;
+export declare function record(value: unknown): value is Record<string, unknown>;
+export declare function stringField(fields: Record<string, PropertyDescriptor>, key: string): string;
+export declare function nativePromise(value: unknown): value is Promise<unknown>;
+export declare function clearStack(error: Error, stack: unknown): void;
+export declare const octaneRouterSnapshotAdapter: AnySerializationAdapter;

package/dist/types/router.d.ts

@@ -0,0 +1,30 @@
+import { type PublicDataOutcome } from '@modern-js/renderer-core/data';
+import type { RendererIdentity } from '@modern-js/renderer-core/identity';
+import { type AnyRouter } from '@octanejs/tanstack-router';
+/** These bindings own matching, preloading, navigation and route component lifetimes. */
+export * from '@octanejs/tanstack-router';
+export { createRouter as createApplicationRouter, RouterProvider as ApplicationRouter, } from '@octanejs/tanstack-router';
+export type { FileSystemDataModule, FileSystemRouteModule, FileSystemRouteOptions, } from './routes';
+export { createFileSystemRouteTree, matchApplicationRouteIds, matchApplicationRoutes, RouteDataError, resolveRouteData, selectApplicationDataRoute, } from './routes';
+/** Read the identity selected by this application's framework composition. */
+export declare function useApplicationIdentity(): Readonly<RendererIdentity>;
+/** Bind an action to its nearest native route, including ancestor layouts. */
+export declare function useApplicationRouteId(): string;
+export interface OctaneRouteActionOptions {
+    readonly router: AnyRouter;
+    readonly routeId: string;
+    readonly identity: RendererIdentity;
+    readonly url?: string | (() => string);
+    readonly method?: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    readonly fetch?: typeof globalThis.fetch;
+    readonly signal?: AbortSignal;
+}
+/** Native useActionState owns submission state and the HTML form action. */
+export declare function createOctaneRouteAction(input: OctaneRouteActionOptions): (_previous: PublicDataOutcome | undefined, formData: FormData) => Promise<PublicDataOutcome>;
+export type OctaneRouteActionBinding = Pick<OctaneRouteActionOptions, 'url' | 'method' | 'fetch'>;
+/**
+ * Bind an action to the nearest native route and to this component's
+ * lifetime: unmounting aborts a submission still in flight, so its late
+ * result cannot redirect or invalidate the route the user moved on to.
+ */
+export declare function useOctaneRouteAction(binding?: OctaneRouteActionBinding): ReturnType<typeof createOctaneRouteAction>;

package/dist/types/routes.d.ts

@@ -0,0 +1,18 @@
+import type { DataOutcome, FileSystemRouteIR, PublicDataOutcome } from '@modern-js/renderer-core/data';
+import { type FileSystemRouteOptions } from '@modern-js/renderer-core/router';
+import { type AnyRoute, type AnyRouter, type ErrorRouteComponent, type NotFoundRouteComponent, type RouteComponent } from '@octanejs/tanstack-router';
+export type { FileSystemDataModule, FileSystemRouteOptions, } from '@modern-js/renderer-core/router';
+export { matchApplicationRouteIds, matchApplicationRoutes, RouteDataError, selectApplicationDataRoute, } from '@modern-js/renderer-core/router';
+/** Generated imports contain native view bindings, keyed by the structural id. */
+export interface FileSystemRouteModule {
+    component?: RouteComponent;
+    pendingComponent?: RouteComponent;
+    errorComponent?: ErrorRouteComponent;
+    notFoundComponent?: NotFoundRouteComponent;
+    validateSearch?: (search: Record<string, unknown>) => Record<string, unknown>;
+    head?: AnyRoute['options']['head'];
+}
+/** Native route boundaries decide how redirects, missing data and errors render. */
+export declare function resolveRouteData(routeId: string, outcome: DataOutcome | PublicDataOutcome): unknown;
+/** Pass filesystem structure to native factories without matching any URL. */
+export declare function createFileSystemRouteTree<Context = unknown>(routes: readonly FileSystemRouteIR[], modules: Readonly<Record<string, FileSystemRouteModule>>, options?: FileSystemRouteOptions<Context, AnyRouter>): AnyRoute;

package/dist/types/server.d.ts

@@ -0,0 +1,41 @@
+import { type DocumentAsset, type DocumentInlineData } from '@modern-js/renderer-core/document';
+import type { NativeFederationBinding } from '@modern-js/renderer-core/federation';
+import { type RequestSession, type ResponsePolicy } from '@modern-js/renderer-core/session';
+import { type ServerRenderNode, type StreamOptions } from 'octane/server';
+export interface OctaneDocumentOptions {
+    /** One identity for this response, shared with the client's signal receiver. */
+    readonly documentId: string;
+    /** Actual native client compilation hash, separate from application identity. */
+    readonly nativeHydrationBuildId: string;
+    readonly rootId?: string;
+    readonly lang?: string;
+    readonly nonce?: string;
+    readonly assets?: readonly DocumentAsset[];
+    /** Placed after the renderer bootstrap and before the entry scripts. */
+    readonly inlineData?: readonly DocumentInlineData[];
+}
+export type { DocumentInlineData as OctaneDocumentInlineData };
+export interface OctaneDocumentResponseOptions<Bindings extends object = object> {
+    readonly session: RequestSession<Bindings>;
+    readonly document: OctaneDocumentOptions;
+    readonly responsePolicy?: ResponsePolicy;
+    /** Native route loading finishes its blocking HTTP work before rendering. */
+    readonly resolveResponse?: (session: RequestSession<Bindings>) => ResponsePolicy | Promise<ResponsePolicy>;
+}
+export interface RenderOctaneApplicationOptions<Bindings extends object = object> extends OctaneDocumentResponseOptions<Bindings> {
+    readonly App: ServerRenderNode;
+    readonly props?: unknown;
+    /** Native router serialization, owned by this request's router SSR context. */
+    readonly injection?: StreamOptions['injection'];
+    /** This server compilation's native Module Federation runtime. */
+    readonly federation?: NativeFederationBinding;
+}
+/** Deliver the CSR document; native browser mounting owns the empty root. */
+export declare function renderOctaneCSRDocument<Bindings extends object>(input: OctaneDocumentResponseOptions<Bindings>): Promise<Response>;
+/**
+ * Render a native Octane application into one request-owned HTML document.
+ * The dispatcher owns the session; this adapter owns native stream consumption
+ * and document placement. A late native error fails the body without changing
+ * the status and headers already sent to the client.
+ */
+export declare function renderOctaneApplication<Bindings extends object>(input: RenderOctaneApplicationOptions<Bindings>): Promise<Response>;

package/dist/types/typecheck.d.ts

@@ -0,0 +1,31 @@
+export interface OctaneTypeDiagnostic {
+    fileName?: string;
+    pos: number;
+    end: number;
+    line?: number;
+    column?: number;
+    code: number | string;
+    category: 'error' | 'warning' | 'message';
+    text: string;
+    origin: 'typescript' | 'octane' | 'projection';
+    relatedInformation?: OctaneTypeDiagnostic[];
+}
+export interface OctaneTypecheckResult {
+    compilerVersion: string;
+    files: string[];
+    diagnostics: OctaneTypeDiagnostic[];
+}
+export interface OctaneTypecheckOptions {
+    project: string;
+    cwd?: string;
+    compilerOptions?: Record<string, unknown>;
+}
+/** Checks authored TSRX through Octane's public language projection and native TS7. */
+export declare function checkOctaneProject(options: OctaneTypecheckOptions): OctaneTypecheckResult;
+export declare function formatOctaneDiagnostic(diagnostic: OctaneTypeDiagnostic, cwd?: string): string;
+/** Node CLI entry. Unsupported options fail visibly instead of being ignored. */
+export declare function runOctaneTypecheck(argv: string[], io?: {
+    cwd?: string;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}): number;