@granite-js/micro-frontend 2.0.0

package/dist/module/specs/PortalHostViewNativeComponent.ts

@@ -0,0 +1,9 @@
+import { codegenNativeComponent, type ViewProps } from "react-native";
+
+interface NativeProps extends ViewProps {
+  readonly name?: string;
+}
+
+export default codegenNativeComponent<NativeProps>("PortalHostView", {
+  interfaceOnly: true,
+});

package/dist/module/specs/PortalViewNativeComponent.ts

@@ -0,0 +1,9 @@
+import { codegenNativeComponent, type ViewProps } from "react-native";
+
+interface NativeProps extends ViewProps {
+  readonly hostName: string;
+}
+
+export default codegenNativeComponent<NativeProps>("PortalView", {
+  interfaceOnly: true,
+});

package/dist/module/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/dist/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["types.ts"],"mappings":"","ignoreList":[]}

package/dist/typescript/createMicroFrontendRuntime.d.ts

@@ -0,0 +1,6 @@
+import type { MicroFrontendAdapter, MicroFrontendRuntimeApi } from './types';
+export interface CreateMicroFrontendRuntimeOptions {
+    readonly adapter: MicroFrontendAdapter;
+    readonly onPreloadError?: (error: unknown) => void;
+}
+export declare function createMicroFrontendRuntime(options: CreateMicroFrontendRuntimeOptions): MicroFrontendRuntimeApi;

package/dist/typescript/createRoute.d.ts

@@ -0,0 +1,23 @@
+import { type RegisterScreenInput, type RouteOptions, useNavigation } from '@granite-js/react-native';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { PendingHostComponentRenderer } from './host/types';
+export type MicroFrontendRouteOptions<TParams extends Readonly<object> | undefined> = RouteOptions<TParams> & {
+    readonly hostPendingComponent?: PendingHostComponentRenderer<TParams>;
+};
+type SetParamsFunction<TParams> = (params: TParams extends undefined ? undefined : Partial<TParams>) => void;
+type ReplaceParamsFunction<TParams> = (params: TParams extends undefined ? undefined : TParams) => void;
+type MicroFrontendRouteResult<TInput, TOutput> = {
+    readonly _path: keyof RegisterScreenInput;
+    readonly useNavigation: typeof useNavigation;
+    readonly useParams: () => TOutput;
+    readonly useSetParams: () => SetParamsFunction<TInput>;
+    readonly useReplaceParams: () => ReplaceParamsFunction<TInput>;
+    readonly _inputType: TInput;
+    readonly _outputType: TOutput;
+};
+export declare function createRoute<TSchema extends StandardSchemaV1<unknown, Readonly<object> | undefined>>(path: keyof RegisterScreenInput, options: Omit<RouteOptions<StandardSchemaV1.InferOutput<TSchema>>, 'validateParams'> & {
+    readonly validateParams: TSchema;
+    readonly hostPendingComponent?: PendingHostComponentRenderer<StandardSchemaV1.InferOutput<TSchema>>;
+}): MicroFrontendRouteResult<StandardSchemaV1.InferInput<TSchema>, StandardSchemaV1.InferOutput<TSchema>>;
+export declare function createRoute<TParams extends Readonly<object> | undefined>(path: keyof RegisterScreenInput, options: MicroFrontendRouteOptions<TParams>): MicroFrontendRouteResult<TParams, TParams>;
+export {};

package/dist/typescript/host/PendingHostComponent.d.ts

@@ -0,0 +1,14 @@
+export interface PendingHostComponentProps {
+    readonly url: string | null | undefined;
+}
+export interface PendingHostComponentController {
+    readonly url: string | null;
+    readonly isPresent: boolean;
+    readonly isHidden: boolean;
+    readonly present: (url: string | null) => void;
+    readonly dismiss: () => void;
+}
+export declare function useIsPendingHostComponentHidden(): boolean;
+export declare function useResolvedPendingHostComponent(url: string | null | undefined): import("./types").ResolvedPendingHostComponent | null;
+export declare function PendingHostComponent({ url }: PendingHostComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function usePendingHostComponentController(): PendingHostComponentController;

package/dist/typescript/host/index.d.ts

@@ -0,0 +1,5 @@
+export type { PendingHostComponentController, PendingHostComponentProps } from './PendingHostComponent';
+export { PendingHostComponent, usePendingHostComponentController, useIsPendingHostComponentHidden, useResolvedPendingHostComponent, } from './PendingHostComponent';
+export type { PendingHostComponentAppConfig, PendingHostComponentRenderer, PendingHostComponentParams, PendingHostComponentRouteRequest, RegisterPendingHostComponentRouteOptions, ResolvedPendingHostComponent, } from './types';
+export { createPendingHostComponentRoutePrefix, normalizeRoutePath, } from './routeMatcher';
+export { hidePendingHostComponent, installPendingHostComponentBridge, registerPendingHostComponentRoute, resetPendingHostComponent, resolvePendingHostComponent, } from './pendingHostComponentStore';

package/dist/typescript/host/pendingHostComponentStore.d.ts

@@ -0,0 +1,11 @@
+import type { PendingHostComponentRouteRequest, RegisterPendingHostComponentRouteOptions, ResolvedPendingHostComponent } from './types';
+export declare function subscribePendingHostComponentStore(listener: () => void): () => boolean;
+export declare function getPendingHostComponentStoreVersion(): number;
+export declare function getIsPendingHostComponentHidden(): boolean;
+export declare function hidePendingHostComponent(): void;
+export declare function resetPendingHostComponent(): void;
+export declare function installPendingHostComponentBridge(): void;
+export declare function registerPendingHostComponentRoute<TParams extends Readonly<object> | undefined = undefined>(routePath: string, options: RegisterPendingHostComponentRouteOptions<TParams>): void;
+export declare function removePendingHostComponentRoutes(appName: string): void;
+export declare function resolvePendingHostComponent(request: PendingHostComponentRouteRequest | string): ResolvedPendingHostComponent | null;
+export declare function resetPendingHostComponentStoreForTest(): void;

package/dist/typescript/host/resolveParams.d.ts

@@ -0,0 +1,10 @@
+import type { ParserParams, ValidateParams } from './types';
+type ResolvedParams = {
+    readonly status: 'resolved';
+    readonly value: Readonly<object>;
+} | {
+    readonly status: 'invalid';
+    readonly cause?: Error;
+};
+export declare function resolvePendingHostComponentParams(rawParams: Record<string, unknown>, parserParams: ParserParams | undefined, validateParams: ValidateParams<Readonly<object> | undefined> | undefined): ResolvedParams;
+export {};

package/dist/typescript/host/routeMatcher.d.ts

@@ -0,0 +1,7 @@
+import type { PendingHostComponentAppConfig } from './types';
+export declare function normalizeRoutePath(routePath: string): string;
+export declare function createPendingHostComponentRoutePrefix(app: PendingHostComponentAppConfig): string;
+export declare function getRoutePathFromUrl(url: string, routePrefix: string): string | null;
+export declare function getQueryParamsFromUrl(url: string): Record<string, string>;
+export declare function matchRoutePath(pattern: string, routePath: string): Record<string, string> | null;
+export declare function normalizePendingHostComponentAppName(appName: string): string;

package/dist/typescript/host/types.d.ts

@@ -0,0 +1,32 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ReactNode } from 'react';
+export type PendingHostComponentParams<TParams extends Readonly<object> | undefined = undefined> = TParams extends Readonly<object> ? TParams : Readonly<Record<string, never>>;
+export type PendingHostComponentRenderer<TParams extends Readonly<object> | undefined = undefined> = {
+    bivarianceHack(params: PendingHostComponentParams<TParams>): ReactNode;
+}['bivarianceHack'];
+export type ParserParams = (params: Record<string, unknown>) => Record<string, unknown>;
+export type ValidateParams<TParams extends Readonly<object> | undefined> = ((params: Readonly<object> | undefined) => TParams) | StandardSchemaV1<unknown, TParams>;
+export interface PendingHostComponentAppConfig {
+    readonly name: string;
+    readonly scheme: string;
+    readonly host?: string | null;
+}
+export interface RegisterPendingHostComponentRouteOptions<TParams extends Readonly<object> | undefined = undefined> {
+    readonly component: PendingHostComponentRenderer<TParams>;
+    readonly parserParams?: ParserParams;
+    readonly validateParams?: ValidateParams<TParams>;
+    readonly app: PendingHostComponentAppConfig;
+}
+export interface PendingHostComponentRouteRequest {
+    readonly routePath: string;
+    readonly params?: Record<string, unknown>;
+    readonly appName: string;
+    readonly url?: string | null;
+}
+export interface ResolvedPendingHostComponent {
+    readonly component: PendingHostComponentRenderer<Readonly<object>>;
+    readonly params: Readonly<object>;
+    readonly url: string | null;
+    readonly routePath: string;
+    readonly appName: string | null;
+}

package/dist/typescript/index.d.ts

@@ -0,0 +1,16 @@
+export { createMicroFrontendRuntime } from './createMicroFrontendRuntime';
+export type { CreateMicroFrontendRuntimeOptions } from './createMicroFrontendRuntime';
+export { createRoute } from './createRoute';
+export type { MicroFrontendRouteOptions } from './createRoute';
+export type { PendingHostComponentController, PendingHostComponentProps } from './host/PendingHostComponent';
+export { PendingHostComponent, usePendingHostComponentController, useIsPendingHostComponentHidden, useResolvedPendingHostComponent, } from './host/PendingHostComponent';
+export type { PendingHostComponentAppConfig, PendingHostComponentRenderer, PendingHostComponentParams, PendingHostComponentRouteRequest, RegisterPendingHostComponentRouteOptions, ResolvedPendingHostComponent, } from './host/types';
+export { createPendingHostComponentRoutePrefix, normalizeRoutePath, } from './host/routeMatcher';
+export { hidePendingHostComponent, installPendingHostComponentBridge, registerPendingHostComponentRoute, resetPendingHostComponent, resolvePendingHostComponent, } from './host/pendingHostComponentStore';
+export { MicroFrontendSessionProvider, MissingMicroFrontendSessionError, useMicroFrontendSession, } from './session/MicroFrontendSessionContext';
+export type { MicroFrontendSession, MicroFrontendSessionProviderProps } from './session/MicroFrontendSessionContext';
+export { useMicroFrontendSessions } from './session/useMicroFrontendSessions';
+export type { MicroFrontendSessionState } from './session/useMicroFrontendSessions';
+export { default as Portal } from './specs/PortalViewNativeComponent';
+export type { AppRequest, MicroFrontendAppProps, MicroFrontendAdapter, MicroFrontendBundle, MicroFrontendBundleRequest, MicroFrontendRuntimeApi, MicroFrontendRuntimeEvent, MicroFrontendRuntimeEventSubscription, MicroFrontendSessionEvent, } from './types';
+export { AppContainerNotFoundError, ExposedModuleNotFoundError, InvalidAppNameError, InvalidAppRequestError, InvalidNativeRuntimeEventError, } from './runtime/errors';

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

@@ -0,0 +1,2 @@
+export { microFrontend } from './microFrontendPlugin';
+export type { MicroFrontendPluginOptions } from './types';

package/dist/typescript/plugin/intoShared.d.ts

@@ -0,0 +1,3 @@
+import type { MicroFrontendPluginOptions } from './types';
+import type { SharedConfig } from '../runtime/registry';
+export declare function intoShared(shared: MicroFrontendPluginOptions['shared']): SharedConfig | undefined;

package/dist/typescript/plugin/microFrontendPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { GranitePluginCore } from '@granite-js/plugin-core';
+import type { MicroFrontendPluginOptions } from './types';
+export declare function microFrontend(options?: MicroFrontendPluginOptions): Promise<GranitePluginCore>;

package/dist/typescript/plugin/prelude.d.ts

@@ -0,0 +1,6 @@
+import type { MicroFrontendPluginOptions } from './types';
+export interface MicroFrontendPreludeConfig {
+    readonly banner: string;
+    readonly preludeScript: string;
+}
+export declare function getPreludeConfig(options: MicroFrontendPluginOptions, appName?: string): MicroFrontendPreludeConfig;

package/dist/typescript/plugin/resolver.d.ts

@@ -0,0 +1,3 @@
+import type { ResolverConfig } from '@granite-js/plugin-core';
+import type { SharedModuleConfig } from '../runtime/registry';
+export declare function createSharedResolverConfig(moduleEntries: readonly (readonly [string, SharedModuleConfig])[]): Pick<ResolverConfig, 'alias' | 'protocols'>;

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

@@ -0,0 +1,5 @@
+import type { SharedConfig } from '../runtime/registry';
+export interface MicroFrontendPluginOptions {
+    readonly shared?: SharedConfig | readonly string[];
+    readonly exposes?: Readonly<Record<string, string>>;
+}

package/dist/typescript/runtime/createMicroFrontendRuntime.d.ts

@@ -0,0 +1,31 @@
+import type { AppRequest, MicroFrontendAdapter, MicroFrontendRuntimeApi, MicroFrontendRuntimeEvent, MicroFrontendRuntimeEventSubscription } from '../types';
+export interface NativeMicroFrontendRuntimeEvent {
+    readonly name: string;
+    readonly params: {
+        readonly appName?: string;
+        readonly sessionId?: string;
+        readonly scheme?: string;
+        readonly isVisible?: boolean;
+    };
+}
+export interface NativeMicroFrontendRuntime {
+    readonly evaluateScript: (request: {
+        readonly filePath: string;
+    }) => Promise<void>;
+    readonly startEventDelivery: () => void;
+    readonly onEvent: (listener: (event: NativeMicroFrontendRuntimeEvent) => void) => MicroFrontendRuntimeEventSubscription;
+}
+export interface MicroFrontendModuleRegistry {
+    readonly hasContainer: (appName: string) => boolean;
+    readonly removeContainer: (appName: string) => void;
+    readonly importModule: <TModule>(request: AppRequest) => TModule;
+}
+export interface CreateMicroFrontendRuntimeDependencies {
+    readonly adapter: MicroFrontendAdapter;
+    readonly nativeRuntime: NativeMicroFrontendRuntime;
+    readonly onPreloadError: (error: unknown) => void;
+    readonly registry: MicroFrontendModuleRegistry;
+    readonly removePendingHostComponentRoutes: (appName: string) => void;
+    readonly parseEvent: (event: NativeMicroFrontendRuntimeEvent) => MicroFrontendRuntimeEvent;
+}
+export declare function createMicroFrontendRuntimeWithDependencies(dependencies: CreateMicroFrontendRuntimeDependencies): MicroFrontendRuntimeApi;

package/dist/typescript/runtime/errors.d.ts

@@ -0,0 +1,35 @@
+export declare class InvalidAppRequestError extends Error {
+    readonly request: string;
+    constructor(request: string);
+}
+export declare class InvalidAppNameError extends Error {
+    readonly appName: string;
+    constructor(appName: string);
+}
+export declare class AppContainerNotFoundError extends Error {
+    readonly appName: string;
+    constructor(appName: string);
+}
+export declare class AppContainerAlreadyRegisteredError extends Error {
+    readonly appName: string;
+    constructor(appName: string);
+}
+export declare class ExposedModuleNotFoundError extends Error {
+    readonly appName: string;
+    readonly exposedModule: string;
+    constructor(appName: string, exposedModule: string);
+}
+export declare class ExposedModuleAlreadyRegisteredError extends Error {
+    readonly appName: string;
+    readonly exposedModule: string;
+    constructor(appName: string, exposedModule: string);
+}
+export declare class SharedModuleAlreadyRegisteredError extends Error {
+    readonly moduleName: string;
+    constructor(moduleName: string);
+}
+export declare class InvalidNativeRuntimeEventError extends Error {
+    readonly eventName: string;
+    readonly fieldName?: string;
+    constructor(eventName: string, fieldName?: string);
+}

package/dist/typescript/runtime/parseAppRequest.d.ts

@@ -0,0 +1,6 @@
+import type { AppRequest } from '../types';
+export interface ParsedAppRequest {
+    readonly appName: string;
+    readonly exposedModule: string;
+}
+export declare function parseAppRequest(request: AppRequest): ParsedAppRequest;

package/dist/typescript/runtime/parseNativeRuntimeEvent.d.ts

@@ -0,0 +1,3 @@
+import type { MicroFrontendRuntimeEvent } from '../types';
+import type { NativeMicroFrontendRuntimeEvent } from './createMicroFrontendRuntime';
+export declare function parseNativeRuntimeEvent(event: NativeMicroFrontendRuntimeEvent): MicroFrontendRuntimeEvent;

package/dist/typescript/runtime/registry.d.ts

@@ -0,0 +1,35 @@
+import type { AppRequest } from '../types';
+import type { MicroFrontendModuleRegistry } from './createMicroFrontendRuntime';
+export interface SharedModuleConfig {
+    readonly eager?: boolean;
+}
+export type SharedConfig = Readonly<Record<string, SharedModuleConfig>>;
+export interface AppContainerConfig {
+    readonly shared?: SharedConfig;
+}
+export interface AppContainer {
+    readonly appName: string;
+    readonly config: AppContainerConfig;
+    readonly exposedModules: Record<string, unknown>;
+}
+interface SharedModule {
+    readonly get: () => unknown;
+    readonly loaded: boolean;
+}
+export interface MicroFrontendRuntimeContext {
+    readonly containers: Record<string, AppContainer>;
+    readonly sharedModules: Record<string, SharedModule>;
+}
+declare global {
+    var _graniteMicroFrontend: MicroFrontendRuntimeContext | undefined;
+}
+export declare function getMicroFrontendRuntimeContext(): MicroFrontendRuntimeContext;
+export declare function createContainer(appName: string, config?: AppContainerConfig): AppContainer;
+export declare function exposeModule(container: AppContainer, exposedModule: string, module: unknown): void;
+export declare function registerShared(moduleName: string, module: unknown): void;
+export declare function getContainer(appName: string): AppContainer | null;
+export declare function removeContainer(appName: string): void;
+export declare function hasContainer(appName: string): boolean;
+export declare function importModule<TModule>(request: AppRequest): TModule;
+export declare const microFrontendModuleRegistry: MicroFrontendModuleRegistry;
+export {};

package/dist/typescript/session/MicroFrontendSessionContext.d.ts

@@ -0,0 +1,13 @@
+import { type ReactElement, type ReactNode } from 'react';
+export interface MicroFrontendSession {
+    readonly sessionId: string;
+}
+export interface MicroFrontendSessionProviderProps extends MicroFrontendSession {
+    readonly children: ReactNode;
+    readonly presentationVisibility: boolean;
+}
+export declare class MissingMicroFrontendSessionError extends Error {
+    constructor();
+}
+export declare function MicroFrontendSessionProvider(props: MicroFrontendSessionProviderProps): ReactElement;
+export declare function useMicroFrontendSession(): MicroFrontendSession;

package/dist/typescript/session/useMicroFrontendSessions.d.ts

@@ -0,0 +1,8 @@
+import type { MicroFrontendRuntimeApi } from '../types';
+export interface MicroFrontendSessionState {
+    readonly appName: string;
+    readonly sessionId: string;
+    readonly scheme: string;
+    readonly isVisible: boolean;
+}
+export declare function useMicroFrontendSessions(runtime: Pick<MicroFrontendRuntimeApi, 'onEvent'>): readonly MicroFrontendSessionState[];

package/dist/typescript/specs/NativeGraniteMicroFrontendRuntime.d.ts

@@ -0,0 +1,21 @@
+import { type CodegenTypes, type TurboModule } from 'react-native';
+export interface NativeMicroFrontendRuntimeEventParams {
+    readonly appName?: string;
+    readonly sessionId?: string;
+    readonly scheme?: string;
+    readonly isVisible?: boolean;
+}
+export interface NativeMicroFrontendRuntimeEvent {
+    readonly name: string;
+    readonly params: NativeMicroFrontendRuntimeEventParams;
+}
+export type EvaluateScriptRequest = Readonly<{
+    filePath: string;
+}>;
+export interface Spec extends TurboModule {
+    evaluateScript(request: EvaluateScriptRequest): Promise<void>;
+    startEventDelivery(): void;
+    readonly onEvent: CodegenTypes.EventEmitter<NativeMicroFrontendRuntimeEvent>;
+}
+declare const NativeGraniteMicroFrontendRuntime: Spec;
+export default NativeGraniteMicroFrontendRuntime;

package/dist/typescript/specs/PortalHostViewNativeComponent.d.ts

@@ -0,0 +1,6 @@
+import { type ViewProps } from "react-native";
+interface NativeProps extends ViewProps {
+    readonly name?: string;
+}
+declare const _default: import("react-native").HostComponent<NativeProps>;
+export default _default;

package/dist/typescript/specs/PortalViewNativeComponent.d.ts

@@ -0,0 +1,6 @@
+import { type ViewProps } from "react-native";
+interface NativeProps extends ViewProps {
+    readonly hostName: string;
+}
+declare const _default: import("react-native").HostComponent<NativeProps>;
+export default _default;

package/dist/typescript/types.d.ts

@@ -0,0 +1,49 @@
+export type AppRequest = `${string}/${string}`;
+export interface MicroFrontendBundleRequest {
+    readonly appName: string;
+}
+export interface MicroFrontendBundle {
+    readonly filePath: string;
+}
+export interface MicroFrontendAppProps {
+    readonly scheme: string;
+}
+export interface MicroFrontendAdapter {
+    readonly loadBundle: (request: MicroFrontendBundleRequest) => Promise<MicroFrontendBundle>;
+}
+export type MicroFrontendRuntimeEvent = {
+    readonly name: 'preloadApp';
+    readonly params: {
+        readonly appName: string;
+    };
+} | {
+    readonly name: 'openApp';
+    readonly params: {
+        readonly sessionId: string;
+        readonly appName: string;
+        readonly scheme: string;
+    };
+} | {
+    readonly name: 'closeApp';
+    readonly params: {
+        readonly sessionId: string;
+    };
+} | {
+    readonly name: 'sessionVisibilityChanged';
+    readonly params: {
+        readonly sessionId: string;
+        readonly isVisible: boolean;
+    };
+};
+export type MicroFrontendSessionEvent = Exclude<MicroFrontendRuntimeEvent, {
+    readonly name: 'preloadApp';
+}>;
+export interface MicroFrontendRuntimeEventSubscription {
+    readonly remove: () => void;
+}
+export interface MicroFrontendRuntimeApi {
+    readonly evaluateScript: (filePath: string) => Promise<void>;
+    readonly preloadApp: (appName: string) => Promise<void>;
+    readonly importApp: <TModule>(request: AppRequest) => Promise<TModule>;
+    readonly onEvent: (listener: (event: MicroFrontendSessionEvent) => void) => MicroFrontendRuntimeEventSubscription;
+}

package/ios/GraniteMicroFrontendRuntimeHost+Internal.h

@@ -0,0 +1,18 @@
+#import "GraniteMicroFrontendRuntimeHost.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol GraniteMicroFrontendRuntimeEventSink <NSObject>
+- (BOOL)enqueueRuntimeEvent:(NSDictionary *)event;
+@end
+
+@interface GraniteMicroFrontendRuntimeHost (Internal)
++ (void)startEventDeliveryToEventSink:(id<GraniteMicroFrontendRuntimeEventSink>)eventSink;
++ (void)detachEventSink:(id<GraniteMicroFrontendRuntimeEventSink>)eventSink;
++ (void)emitOpenApp:(NSString *)sessionId appName:(NSString *)appName scheme:(NSString *)scheme;
++ (void)emitCloseApp:(NSString *)sessionId;
++ (void)emitSessionVisibilityChanged:(NSString *)sessionId isVisible:(BOOL)isVisible;
++ (void)unregisterSession:(NSString *)sessionId token:(NSString *)token;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/GraniteMicroFrontendRuntimeHost.h

@@ -0,0 +1,34 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class UIViewController;
+
+@interface GraniteMicroFrontendSessionRegistration : NSObject
+- (void)openAppWithAppName:(NSString *)appName scheme:(NSString *)scheme;
+- (BOOL)setVisible:(BOOL)isVisible;
+- (BOOL)closeApp;
+- (void)invalidate;
+@end
+
+@interface GraniteMicroFrontendViewControllerSessionBinding : NSObject
+/// Returns an existing binding if this view controller is already bound.
+/// Returns `nil` if `sessionId` is already registered on another container.
++ (nullable GraniteMicroFrontendViewControllerSessionBinding *)bindViewController:(UIViewController *)viewController
+                                                                        sessionId:(NSString *)sessionId
+                                                                          appName:(NSString *)appName
+                                                                           scheme:(NSString *)scheme;
+- (void)invalidate;
+@end
+
+@interface GraniteMicroFrontendRuntimeHost : NSObject
+
+/// Registers a session. Returns `nil` if `sessionId` is already registered.
+/// Callers must use a unique id per destination and invalidate before reuse.
++ (nullable GraniteMicroFrontendSessionRegistration *)registerSession:(NSString *)sessionId;
+
++ (void)emitPreloadApp:(NSString *)appName;
+
+@end
+
+NS_ASSUME_NONNULL_END