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

package/dist/esm-node/typecheck.mjs

@@ -0,0 +1,560 @@
+import { randomUUID } from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { SourceMap, shouldReportDiagnostics } from "@volar/language-core";
+import { findNodeAtLocation, getNodeValue, parse, parseTree } from "jsonc-parser";
+import { compileToVolarMappings } from "octane/compiler/volar";
+import { version } from "typescript";
+import { createVirtualFileSystem } from "typescript/unstable/fs";
+import { API } from "typescript/unstable/sync";
+const nativeExtension = /\.tsrx$/u;
+const projectedExtension = /\.tsrx\.tsx$/u;
+function typecheck_location(source, pos) {
+    const prefix = source.slice(0, pos);
+    const lines = prefix.split(/\r\n|\r|\n/u);
+    return {
+        line: lines.length,
+        column: (lines.at(-1)?.length ?? 0) + 1
+    };
+}
+function readFile(file) {
+    try {
+        return node_fs.readFileSync(file, 'utf8');
+    } catch (error) {
+        if (error instanceof Error && 'code' in error && ('ENOENT' === error.code || 'ENOTDIR' === error.code)) return;
+        throw error;
+    }
+}
+function projectConfig(source, fileName, discovery, roots) {
+    const errors = [];
+    const config = parseTree(source.replace(/^\uFEFF/u, ' '), errors, {
+        allowTrailingComma: true
+    });
+    if (errors.length || !config || 'object' !== config.type) return;
+    const edits = [];
+    const additions = [];
+    for (const field of [
+        'files',
+        'include',
+        'exclude'
+    ]){
+        const array = findNodeAtLocation(config, [
+            field
+        ]);
+        if (roots) {
+            const content = JSON.stringify('files' === field ? roots : []);
+            if (array) {
+                if ('array' === array.type && (array.children ?? []).every((node)=>'string' === node.type)) edits.push({
+                    offset: array.offset,
+                    length: array.length,
+                    content
+                });
+            } else additions.push(`${JSON.stringify(field)}:${content}`);
+            continue;
+        }
+        if (array?.type === 'array') for (const node of array.children ?? []){
+            const file = getNodeValue(node);
+            if ('string' != typeof file) continue;
+            const projected = 'files' === field || 'complete' === discovery ? nativeExtension.test(file) ? `${file}.tsx` : file : 'native' === discovery && /[.*?]/u.test(file.replaceAll('\\', '/').split('/').at(-1) ?? '') ? `${file.endsWith('/**') ? `${file}/*` : file}.tsx` : file;
+            if (projected !== file) edits.push({
+                offset: node.offset,
+                length: node.length,
+                content: JSON.stringify(projected)
+            });
+        }
+    }
+    if (additions.length) edits.push({
+        offset: config.offset + 1,
+        length: 0,
+        content: `${additions.join(',')}${config.children?.length ? ',' : ''}`
+    });
+    if (!edits.length) return;
+    const mappings = [];
+    let sourceOffset = 0;
+    let code = '';
+    for (const edit of edits.sort((left, right)=>left.offset - right.offset)){
+        const unchanged = source.slice(sourceOffset, edit.offset);
+        mappings.push({
+            sourceOffsets: [
+                sourceOffset
+            ],
+            generatedOffsets: [
+                code.length
+            ],
+            lengths: [
+                unchanged.length
+            ],
+            data: {
+                verification: true
+            }
+        });
+        code += unchanged;
+        mappings.push({
+            sourceOffsets: [
+                edit.offset
+            ],
+            generatedOffsets: [
+                code.length
+            ],
+            lengths: [
+                edit.length
+            ],
+            generatedLengths: [
+                edit.content.length
+            ],
+            data: {
+                verification: true
+            }
+        });
+        code += edit.content;
+        sourceOffset = edit.offset + edit.length;
+    }
+    mappings.push({
+        sourceOffsets: [
+            sourceOffset
+        ],
+        generatedOffsets: [
+            code.length
+        ],
+        lengths: [
+            source.length - sourceOffset
+        ],
+        data: {
+            verification: true
+        }
+    });
+    code += source.slice(sourceOffset);
+    return {
+        source,
+        fileName,
+        code,
+        map: new SourceMap(mappings)
+    };
+}
+function diagnosticText(diagnostic) {
+    return [
+        diagnostic.text,
+        ...diagnostic.messageChain?.map(diagnosticText) ?? []
+    ].join('\n');
+}
+function checkOctaneProject(options) {
+    if ('7.0.2' !== version) throw new Error(`Octane typechecking requires TypeScript 7.0.2; found ${version}`);
+    const cwd = node_path.resolve(options.cwd ?? process.cwd());
+    let project = node_path.resolve(cwd, options.project);
+    if (node_fs.existsSync(project) && node_fs.statSync(project).isDirectory()) project = node_path.join(project, 'tsconfig.json');
+    if (!node_fs.existsSync(project)) throw new Error(`Cannot find project ${project}`);
+    if (options.compilerOptions?.noEmit === false || options.compilerOptions?.noCheck === true || options.compilerOptions?.skipLibCheck === true || options.compilerOptions?.skipDefaultLibCheck === true) throw new Error('Octane typechecking requires noEmit, full checking, and library checking');
+    const effectiveConfig = node_path.join(node_path.dirname(project), `.octane-typecheck-${randomUUID()}.json`);
+    const authoredConfig = parse((readFile(project) ?? '').replace(/^\uFEFF/u, ' '), [], {
+        allowTrailingComma: true
+    });
+    const effectiveOptions = {
+        extends: project,
+        ...Array.isArray(authoredConfig?.references) ? {
+            references: authoredConfig.references
+        } : {},
+        compilerOptions: {
+            ...options.compilerOptions,
+            noEmit: true,
+            noCheck: false,
+            skipLibCheck: false,
+            skipDefaultLibCheck: false
+        }
+    };
+    const virtual = createVirtualFileSystem({
+        [effectiveConfig]: JSON.stringify(effectiveOptions)
+    });
+    const projections = new Map();
+    const configurations = new Map();
+    const configFiles = new Set([
+        project
+    ]);
+    const referencedConfigs = new Set([
+        project
+    ]);
+    const referenceRoots = new Map();
+    let discovery = 'ordinary';
+    function authoredName(file) {
+        if (!projectedExtension.test(file)) return file;
+        const authored = file.slice(0, -4);
+        if (!node_fs.existsSync(authored)) return file;
+        if (node_fs.existsSync(file)) throw new Error(`Octane projection collision: ${authored} conflicts with physical ${file}`);
+        return authored;
+    }
+    function projection(file) {
+        const fileName = authoredName(file);
+        if (fileName === file) return;
+        const known = projections.get(file);
+        if (known) return known;
+        const source = readFile(fileName);
+        if (void 0 === source) return;
+        let compiled;
+        try {
+            compiled = compileToVolarMappings(source, fileName, {
+                loose: true
+            });
+        } catch (error) {
+            if (!(error instanceof SyntaxError)) throw error;
+            compiled = {
+                code: 'export {};',
+                mappings: [],
+                diagnostics: [],
+                errors: [
+                    {
+                        name: error.name,
+                        message: error.message,
+                        fileName,
+                        type: 'fatal',
+                        ...'pos' in error && 'number' == typeof error.pos ? {
+                            pos: error.pos
+                        } : {},
+                        ...'end' in error && 'number' == typeof error.end ? {
+                            end: error.end
+                        } : {}
+                    }
+                ]
+            };
+        }
+        const result = {
+            ...compiled,
+            source,
+            fileName,
+            map: new SourceMap(compiled.mappings)
+        };
+        projections.set(file, result);
+        virtual.writeFile?.(file, compiled.code);
+        return result;
+    }
+    const overlay = {
+        readFile (file) {
+            const content = virtual.readFile?.(file);
+            if (void 0 !== content) return content;
+            const compiled = projection(file);
+            if (compiled) return compiled.code;
+            if (file.endsWith('.json')) {
+                const source = readFile(file);
+                if (void 0 !== source) {
+                    if (!configFiles.has(file) && ('complete' === discovery || 'package.json' === node_path.basename(file))) return source;
+                    configFiles.add(file);
+                    const configData = parse(source.replace(/^\uFEFF/u, ' '), [], {
+                        allowTrailingComma: true
+                    });
+                    for (const reference of referencedConfigs.has(file) && Array.isArray(configData?.references) ? configData.references : []){
+                        if ('string' != typeof reference?.path) continue;
+                        const target = node_path.resolve(node_path.dirname(file), reference.path);
+                        const referenceFile = target.endsWith('.json') ? target : node_path.join(target, 'tsconfig.json');
+                        configFiles.add(referenceFile);
+                        referencedConfigs.add(referenceFile);
+                    }
+                    const roots = 'complete' === discovery ? referenceRoots.get(file) : void 0;
+                    const config = projectConfig(source, file, discovery, roots ? [
+                        ...roots
+                    ] : void 0);
+                    if (config) configurations.set(file, config);
+                    else configurations.delete(file);
+                    return config?.code ?? source;
+                }
+            }
+        },
+        fileExists (file) {
+            if (virtual.fileExists?.(file)) return true;
+            if (authoredName(file) !== file) return true;
+        },
+        directoryExists (directory) {
+            return virtual.directoryExists?.(directory) || void 0;
+        },
+        getAccessibleEntries (directory) {
+            const files = new Set(virtual.getAccessibleEntries?.(directory)?.files);
+            const directories = new Set(virtual.getAccessibleEntries?.(directory)?.directories);
+            try {
+                for (const entry of node_fs.readdirSync(directory, {
+                    withFileTypes: true
+                })){
+                    let isDirectory = entry.isDirectory();
+                    if (entry.isSymbolicLink()) try {
+                        isDirectory = node_fs.statSync(node_path.join(directory, entry.name)).isDirectory();
+                    } catch (error) {
+                        if (error instanceof Error && 'code' in error && ('ENOENT' === error.code || 'ENOTDIR' === error.code)) continue;
+                        throw error;
+                    }
+                    if (isDirectory) directories.add(entry.name);
+                    else {
+                        files.add(entry.name);
+                        if (nativeExtension.test(entry.name)) {
+                            const projected = node_path.join(directory, `${entry.name}.tsx`);
+                            authoredName(projected);
+                            files.add(`${entry.name}.tsx`);
+                        }
+                    }
+                }
+            } catch (error) {
+                if (!(error instanceof Error && 'code' in error && ('ENOENT' === error.code || 'ENOTDIR' === error.code))) throw error;
+            }
+            return {
+                files: [
+                    ...files
+                ].filter((file)=>'ordinary' !== discovery || authoredName(node_path.join(directory, file)) === node_path.join(directory, file)).sort(),
+                directories: [
+                    ...directories
+                ].sort()
+            };
+        },
+        realpath (file) {
+            const authored = authoredName(file);
+            if (authored !== file) try {
+                return `${node_fs.realpathSync(authored)}.tsx`;
+            } catch  {
+                return;
+            }
+            return virtual.fileExists?.(file) ? file : void 0;
+        }
+    };
+    const roots = new Set();
+    for (const mode of [
+        'ordinary',
+        'native'
+    ]){
+        discovery = mode;
+        const parser = new API({
+            cwd,
+            fs: overlay
+        });
+        try {
+            for (const file of parser.parseConfigFile(effectiveConfig).fileNames)if ('ordinary' === mode || authoredName(file) !== file) roots.add(file);
+            const parsedReferences = new Set([
+                project
+            ]);
+            for (const reference of referencedConfigs){
+                if (parsedReferences.has(reference)) continue;
+                parsedReferences.add(reference);
+                const selected = referenceRoots.get(reference) ?? new Set();
+                referenceRoots.set(reference, selected);
+                for (const file of parser.parseConfigFile(reference).fileNames)if ('ordinary' === mode || authoredName(file) !== file) selected.add(file);
+            }
+        } finally{
+            parser.close();
+        }
+    }
+    discovery = 'complete';
+    virtual.writeFile?.(effectiveConfig, JSON.stringify({
+        ...effectiveOptions,
+        files: [
+            ...roots
+        ],
+        include: [],
+        exclude: []
+    }));
+    const api = new API({
+        cwd,
+        fs: overlay
+    });
+    try {
+        const snapshot = api.updateSnapshot({
+            openProjects: [
+                effectiveConfig
+            ],
+            openFiles: [
+                ...roots
+            ]
+        });
+        const program = snapshot.getProject(effectiveConfig)?.program;
+        if (!program) throw new Error(`Native TypeScript did not load project ${project}`);
+        function remap(diagnostic) {
+            const relatedInformation = diagnostic.relatedInformation?.flatMap((info)=>{
+                const mapped = remap(info);
+                return mapped ? [
+                    mapped
+                ] : [];
+            });
+            const text = diagnosticText(diagnostic);
+            const compiled = diagnostic.fileName ? projections.get(diagnostic.fileName) ?? configurations.get(diagnostic.fileName) : void 0;
+            let pos = diagnostic.pos;
+            let end = diagnostic.end;
+            let origin = "typescript";
+            let message = text;
+            if (compiled) {
+                const ranges = compiled.map.toSourceRange(pos, end, true, (info)=>shouldReportDiagnostics(info, void 0, diagnostic.code));
+                const range = ranges.next().value;
+                if (range) [pos, end] = range;
+                else {
+                    if (!compiled.map.toSourceRange(pos, end, true).next().done) return;
+                    origin = 'projection';
+                    message = `Cannot map native TS${diagnostic.code} at generated offsets ${pos}-${end}: ${text}`;
+                    pos = 0;
+                    end = 0;
+                }
+            }
+            const fileName = compiled?.fileName ?? (diagnostic.fileName === effectiveConfig ? void 0 : diagnostic.fileName);
+            const source = compiled?.source ?? (fileName ? readFile(fileName) : void 0);
+            return {
+                ...fileName ? {
+                    fileName
+                } : {},
+                pos,
+                end,
+                ...void 0 !== source ? typecheck_location(source, pos) : {},
+                code: diagnostic.code,
+                category: 'projection' === origin || 1 === diagnostic.category ? 'error' : 0 === diagnostic.category ? 'warning' : 'message',
+                text: message,
+                origin,
+                ...relatedInformation?.length ? {
+                    relatedInformation
+                } : {}
+            };
+        }
+        const diagnostics = [
+            ...program.getConfigFileParsingDiagnostics(),
+            ...program.getProgramDiagnostics(),
+            ...program.getGlobalDiagnostics(),
+            ...program.getSyntacticDiagnostics(),
+            ...program.getBindDiagnostics(),
+            ...program.getSemanticDiagnostics()
+        ].flatMap((diagnostic)=>{
+            const mapped = remap(diagnostic);
+            return mapped ? [
+                mapped
+            ] : [];
+        });
+        const nativeFiles = program.getSourceFileNames();
+        for (const file of nativeFiles){
+            const compiled = projections.get(file);
+            if (compiled) {
+                for (const diagnostic of compiled.diagnostics)diagnostics.push({
+                    fileName: compiled.fileName,
+                    pos: diagnostic.start.offset,
+                    end: diagnostic.end.offset,
+                    ...typecheck_location(compiled.source, diagnostic.start.offset),
+                    code: diagnostic.code,
+                    category: 'error' === diagnostic.severity ? 'error' : 'warning' === diagnostic.severity ? 'warning' : 'message',
+                    text: diagnostic.message,
+                    origin: 'octane'
+                });
+                for (const error of compiled.errors){
+                    const pos = error.pos ?? 0;
+                    diagnostics.push({
+                        fileName: compiled.fileName,
+                        pos,
+                        end: error.end ?? pos,
+                        ...typecheck_location(compiled.source, pos),
+                        code: 'OCTANE_PARSE',
+                        category: 'error',
+                        text: error.message,
+                        origin: 'octane'
+                    });
+                }
+            }
+        }
+        const unique = new Map(diagnostics.map((diagnostic)=>[
+                JSON.stringify(diagnostic),
+                diagnostic
+            ]));
+        return {
+            compilerVersion: version,
+            files: [
+                ...new Set(nativeFiles.map((file)=>projections.get(file)?.fileName ?? file))
+            ].sort(),
+            diagnostics: [
+                ...unique.values()
+            ].sort((left, right)=>(left.fileName ?? '').localeCompare(right.fileName ?? '') || left.pos - right.pos || String(left.code).localeCompare(String(right.code)))
+        };
+    } finally{
+        api.close();
+    }
+}
+function formatOctaneDiagnostic(diagnostic, cwd = process.cwd()) {
+    const file = diagnostic.fileName ? `${node_path.relative(cwd, diagnostic.fileName)}(${diagnostic.line ?? 1},${diagnostic.column ?? 1}): ` : '';
+    const code = 'number' == typeof diagnostic.code ? `TS${diagnostic.code}` : diagnostic.code;
+    const related = diagnostic.relatedInformation?.map((info)=>`  ${formatOctaneDiagnostic(info, cwd)}`).join('\n');
+    return `${file}${diagnostic.category} ${code}: ${diagnostic.text}${related ? `\n${related}` : ''}`;
+}
+const booleanOptions = new Set([
+    'strict',
+    'isolatedModules',
+    'verbatimModuleSyntax',
+    'allowImportingTsExtensions',
+    'allowJs',
+    'esModuleInterop',
+    'noUncheckedIndexedAccess',
+    'exactOptionalPropertyTypes',
+    'noImplicitOverride',
+    'noFallthroughCasesInSwitch',
+    'noPropertyAccessFromIndexSignature',
+    'noImplicitReturns',
+    'resolveJsonModule',
+    'strictNullChecks',
+    'strictFunctionTypes',
+    'strictBindCallApply',
+    'strictPropertyInitialization',
+    'noImplicitAny',
+    'noImplicitThis',
+    'useUnknownInCatchVariables',
+    'alwaysStrict'
+]);
+const stringOptions = new Set([
+    'target',
+    'module',
+    'moduleResolution',
+    'moduleDetection',
+    'jsx',
+    'jsxImportSource'
+]);
+function runOctaneTypecheck(argv, io = {}) {
+    const stdout = io.stdout ?? ((text)=>process.stdout.write(text));
+    const stderr = io.stderr ?? ((text)=>process.stderr.write(text));
+    try {
+        let project = 'tsconfig.json';
+        let listFiles = false;
+        const compilerOptions = {};
+        for(let index = 0; index < argv.length; index++){
+            const argument = argv[index];
+            if ('--version' === argument || '-v' === argument) {
+                stdout(`Version ${version}\n`);
+                return 0;
+            }
+            if ('--help' === argument || '-h' === argument) {
+                stdout('octane-tsc --project <tsconfig.json> [--noEmit] [--strict]\n');
+                return 0;
+            }
+            if ('--project' === argument || '-p' === argument) {
+                const value = argv[++index];
+                if (!value || value.startsWith('-')) throw new Error('--project requires a configuration path');
+                project = value;
+                continue;
+            }
+            if (!argument?.startsWith('--')) throw new Error(`Unsupported Octane typecheck argument ${argument}`);
+            const name = argument.slice(2);
+            if (booleanOptions.has(name) || [
+                'noEmit',
+                'noCheck',
+                'skipLibCheck',
+                'skipDefaultLibCheck',
+                'pretty',
+                'listFiles',
+                'explainFiles'
+            ].includes(name)) {
+                const explicit = argv[index + 1];
+                const value = 'true' === explicit || 'false' === explicit ? 'true' === argv[++index] : true;
+                if ('noEmit' === name && !value || ('noCheck' === name || 'skipLibCheck' === name || 'skipDefaultLibCheck' === name) && value) throw new Error(`--${name} ${value} is incompatible with full Octane typechecking`);
+                if ('listFiles' === name || 'explainFiles' === name) listFiles ||= value;
+                else if ('pretty' !== name) compilerOptions[name] = value;
+            } else if (stringOptions.has(name) || 'lib' === name || 'types' === name) {
+                const value = argv[++index];
+                if (!value || value.startsWith('-')) throw new Error(`--${name} requires a value`);
+                compilerOptions[name] = 'lib' === name || 'types' === name ? value.split(',') : value;
+            } else throw new Error(`Unsupported Octane typecheck option --${name}`);
+        }
+        const cwd = node_path.resolve(io.cwd ?? process.cwd());
+        const result = checkOctaneProject({
+            project,
+            cwd,
+            compilerOptions
+        });
+        for (const diagnostic of result.diagnostics)stdout(`${formatOctaneDiagnostic(diagnostic, cwd)}\n`);
+        if (listFiles) for (const file of result.files)stdout(`${file}\n`);
+        return result.diagnostics.some((diagnostic)=>'error' === diagnostic.category) ? 1 : 0;
+    } catch (error) {
+        stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
+export { checkOctaneProject, formatOctaneDiagnostic, runOctaneTypecheck };

package/dist/types/bootstrap.d.ts

@@ -0,0 +1,10 @@
+import { type DocumentBootstrap } from '@modern-js/renderer-core/document';
+import { type RendererIdentity } from '@modern-js/renderer-core/identity';
+export interface OctaneDocumentBootstrap extends DocumentBootstrap {
+    /** Actual native client compilation hash, separate from application identity. */
+    readonly nativeHydrationBuildId: string;
+}
+export declare function assertNativeHydrationBuildId(value: unknown): asserts value is string;
+export declare function assertOctaneIdentity(identity: RendererIdentity): void;
+/** Read the server's bootstrap and require this exact native client build. */
+export declare function readOctaneDocumentBootstrap(document: Document, expectedIdentity: RendererIdentity, expectedNativeHydrationBuildId?: string): OctaneDocumentBootstrap;

package/dist/types/client.d.ts

@@ -0,0 +1,36 @@
+import type { NativeFederationBinding } from '@modern-js/renderer-core/federation';
+import { type RendererIdentity } from '@modern-js/renderer-core/identity';
+import { type ComponentBody, type Root, type RootContainer, type RootOptions } from 'octane';
+export type { OctaneDocumentBootstrap } from './bootstrap';
+export { readOctaneDocumentBootstrap } from './bootstrap';
+export interface OctaneApplicationModule {
+    readonly default: ComponentBody;
+    readonly props?: Record<string, unknown>;
+    /** Request-independent resources owned by this browser application module. */
+    readonly dispose?: () => void;
+}
+export interface OctaneApplicationHandle {
+    readonly root: Root;
+    readonly identity: Readonly<RendererIdentity>;
+    update(application: OctaneApplicationModule): void;
+    dispose(): void;
+}
+export interface OctaneApplicationOptions {
+    readonly container: Exclude<RootContainer, Document>;
+    readonly identity: RendererIdentity;
+    readonly nativeHydrationBuildId: string;
+    /** Cancels startup ownership and retires an active application. */
+    readonly signal?: AbortSignal;
+    /** Hydration installs the native signal bridge before invoking this importer. */
+    readonly load: () => Promise<OctaneApplicationModule>;
+    readonly options?: Omit<RootOptions, 'signalOwner'>;
+    /** This browser compilation's native Module Federation runtime. */
+    readonly federation?: NativeFederationBinding;
+}
+export interface OctaneHydrationOptions extends OctaneApplicationOptions {
+    readonly documentIdentity: RendererIdentity;
+    readonly documentNativeHydrationBuildId: string;
+    readonly documentId: string;
+}
+export declare function mountOctaneApplication(input: OctaneApplicationOptions): Promise<OctaneApplicationHandle>;
+export declare function hydrateOctaneApplication(input: OctaneHydrationOptions): Promise<OctaneApplicationHandle>;

package/dist/types/entry-application.d.ts

@@ -0,0 +1,19 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import type { NativeI18nView } from '@modern-js/renderer-core/entry-client';
+import type { NativeRouterFactory } from '@modern-js/renderer-core/router';
+import { type AnyRoute, type AnyRouter } from '@octanejs/tanstack-router';
+import { type ComponentBody } from 'octane';
+export type OctaneI18nView = NativeI18nView<unknown, LocalisedUrlsOption>;
+/** Wrap a component entry in its request's or document's i18n provider. */
+export declare function componentView(component: unknown, i18n?: OctaneI18nView): ComponentBody;
+/** The Octane route tree and router of a generated entry. */
+export declare const octaneRouterFactory: NativeRouterFactory<AnyRoute, AnyRouter>;
+interface LocalizedRouterProps {
+    readonly router: AnyRouter;
+    readonly i18n: OctaneI18nView;
+}
+/** Wrap a router root in the request's or document's i18n provider. */
+export declare function localizedRouterRoot(Root: ComponentBody<{
+    router: AnyRouter;
+}>): ComponentBody<LocalizedRouterProps>;
+export {};

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

@@ -0,0 +1,8 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import { type NativeClientEntryOptions, type NativeI18nInstance } from '@modern-js/renderer-core/entry-client';
+export interface OctaneClientEntryOptions extends NativeClientEntryOptions<NativeI18nInstance, LocalisedUrlsOption> {
+    /** The native client compilation hash, `__webpack_hash__`. */
+    readonly nativeHydrationBuildId: string;
+}
+/** Start a generated Octane browser entry: mount, or hydrate the server document. */
+export declare function startNativeClient(options: OctaneClientEntryOptions): void;

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

@@ -0,0 +1,11 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import { type NativeI18nInstance, type NativeServerEntry, type NativeServerEntryOptions } from '@modern-js/renderer-core/entry-server';
+import type { ResponsePolicy } from '@modern-js/renderer-core/session';
+/**
+ * The loader projection strips representation fields; the ones an Octane route
+ * declares for the document itself are kept, as Solid document headers are.
+ */
+export declare function withOctaneDocumentFields(policy: ResponsePolicy, responseHeaders: Headers): ResponsePolicy;
+export type OctaneServerEntryOptions = NativeServerEntryOptions<NativeI18nInstance, LocalisedUrlsOption>;
+/** The native transport handlers of a generated Octane server entry. */
+export declare function createNativeServerEntry(options: OctaneServerEntryOptions): NativeServerEntry;

package/dist/types/federation-context.d.ts

@@ -0,0 +1,28 @@
+import { type FederationInstance, type NativeFederationBinding } from '@modern-js/renderer-core/federation';
+import { type ComponentBody } from 'octane';
+/** One application owns its host runtime; each response owns its render scope. */
+export interface OctaneFederationScope {
+    readonly instance: FederationInstance | undefined;
+    readonly server: boolean;
+    readonly nonce?: string;
+}
+export declare const FederationContext: import("octane").Context<OctaneFederationScope | null>;
+export declare function createFederationScope(binding: NativeFederationBinding | undefined, server: boolean, nonce?: string): OctaneFederationScope;
+export declare function FederationRoot(props: {
+    readonly scope: OctaneFederationScope;
+    readonly children?: unknown;
+}): import("octane").ElementDescriptor<{
+    value: OctaneFederationScope;
+    children: unknown;
+}>;
+/** A stable root component retains native state when its application updates. */
+export declare function FederationApplication(props: {
+    readonly scope: OctaneFederationScope;
+    readonly application: {
+        readonly default: ComponentBody;
+        readonly props?: unknown;
+    };
+}): import("octane").ElementDescriptor<{
+    scope: OctaneFederationScope;
+    children: import("octane").ElementDescriptor<unknown>;
+}>;