ink-cartridge 3.6.1

package/dist/language/hook.d.ts

@@ -0,0 +1,19 @@
+import type { I18nContextValue } from './types.js';
+/**
+ * Access the i18n API from within a component tree wrapped by
+ * {@link LanguageProvider}.
+ *
+ * Returns `{ t, setLanguage, getLanguages, mergeLanguage, currentLanguage }`.
+ *
+ * Must be used inside `<LanguageProvider>`. Throws with a clear error
+ * message if no provider is found in the component tree.
+ *
+ * @example
+ * ```tsx
+ * function Greeting() {
+ *   const { t, setLanguage } = useI18n();
+ *   return <Text>{t('hello')}</Text>;
+ * }
+ * ```
+ */
+export declare function useI18n(): I18nContextValue;

package/dist/language/hook.js

@@ -0,0 +1,26 @@
+import { useContext } from 'react';
+import { LanguageContext } from './context.js';
+/**
+ * Access the i18n API from within a component tree wrapped by
+ * {@link LanguageProvider}.
+ *
+ * Returns `{ t, setLanguage, getLanguages, mergeLanguage, currentLanguage }`.
+ *
+ * Must be used inside `<LanguageProvider>`. Throws with a clear error
+ * message if no provider is found in the component tree.
+ *
+ * @example
+ * ```tsx
+ * function Greeting() {
+ *   const { t, setLanguage } = useI18n();
+ *   return <Text>{t('hello')}</Text>;
+ * }
+ * ```
+ */
+export function useI18n() {
+    const ctx = useContext(LanguageContext);
+    if (!ctx) {
+        throw new Error('[Ink-Cartridge] useI18n() must be called inside a <LanguageProvider>.');
+    }
+    return ctx;
+}

package/dist/language/index.d.ts

@@ -0,0 +1,3 @@
+export { LanguageProvider } from './provider.js';
+export { useI18n } from './hook.js';
+export type { LanguageProviderProps, I18nContextValue } from './types.js';

package/dist/language/index.js

@@ -0,0 +1,2 @@
+export { LanguageProvider } from './provider.js';
+export { useI18n } from './hook.js';

package/dist/language/provider.d.ts

@@ -0,0 +1,30 @@
+import React, { ReactNode } from 'react';
+interface LanguageProviderProps {
+    children: ReactNode;
+    resources?: Record<string, Record<string, string>>;
+    path?: string;
+    defaultLanguage?: string;
+    fallbackLanguage?: string;
+    defaultContext?: string;
+}
+/**
+ * Context provider for internationalization (i18n).
+ *
+ * Loads translation resources either from a directory of `{locale}.json` files
+ * (via the `path` prop) or from a pre-built inline object (via `resources`).
+ *
+ * Once mounted, descendant components can use the {@link useI18n} hook to
+ * access the `t()` translation function, `setLanguage()` to switch locales,
+ * and `getLanguages()` / `currentLanguage` for language discovery.
+ *
+ * Language switches trigger an immediate re-render of all consumer components.
+ *
+ * @example
+ * ```tsx
+ * <LanguageProvider path="./locales" defaultLanguage="en-US">
+ *   <MyApp />
+ * </LanguageProvider>
+ * ```
+ */
+export declare function LanguageProvider({ children, resources: inlineResources, path, defaultLanguage, fallbackLanguage, defaultContext, }: LanguageProviderProps): React.JSX.Element;
+export {};

package/dist/language/provider.js

@@ -0,0 +1,155 @@
+import React, { useState, useMemo, useCallback } from 'react';
+import { readFileSync, readdirSync } from 'fs';
+import { resolve } from 'path';
+import { LanguageContext } from './context.js';
+function loadFromPath(dirPath) {
+    const resources = {};
+    let files;
+    try {
+        files = readdirSync(dirPath);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`[Ink-Cartridge] LanguageProvider failed to read directory "${dirPath}": ${msg}`);
+    }
+    for (const file of files) {
+        if (file.endsWith('.json')) {
+            const lang = file.replace('.json', '');
+            const fullPath = resolve(dirPath, file);
+            let raw;
+            try {
+                raw = readFileSync(fullPath, 'utf-8');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                throw new Error(`[Ink-Cartridge] LanguageProvider failed to read "${fullPath}": ${msg}`);
+            }
+            try {
+                resources[lang] = flatJSON(JSON.parse(raw));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                throw new Error(`[Ink-Cartridge] LanguageProvider failed to parse "${file}" as JSON: ${msg}`);
+            }
+        }
+    }
+    return resources;
+}
+function flatJSON(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string') {
+            result[fullKey] = value;
+        }
+        else if (typeof value === 'number' || typeof value === 'boolean') {
+            result[fullKey] = String(value);
+        }
+        else if (Array.isArray(value)) {
+            result[fullKey] = value.map((v) => String(v)).join(', ');
+        }
+        else if (typeof value === 'object' && value !== null) {
+            Object.assign(result, flatJSON(value, fullKey));
+        }
+    }
+    return result;
+}
+function interpolate(template, params) {
+    if (!params)
+        return template;
+    return template.replace(/\{(\w+)\}/g, (_, key) => String(params[key] ?? `{${key}}`));
+}
+/**
+ * Context provider for internationalization (i18n).
+ *
+ * Loads translation resources either from a directory of `{locale}.json` files
+ * (via the `path` prop) or from a pre-built inline object (via `resources`).
+ *
+ * Once mounted, descendant components can use the {@link useI18n} hook to
+ * access the `t()` translation function, `setLanguage()` to switch locales,
+ * and `getLanguages()` / `currentLanguage` for language discovery.
+ *
+ * Language switches trigger an immediate re-render of all consumer components.
+ *
+ * @example
+ * ```tsx
+ * <LanguageProvider path="./locales" defaultLanguage="en-US">
+ *   <MyApp />
+ * </LanguageProvider>
+ * ```
+ */
+export function LanguageProvider({ children, resources: inlineResources, path, defaultLanguage, fallbackLanguage, defaultContext, }) {
+    const rawResources = useMemo(() => {
+        if (inlineResources) {
+            const flat = {};
+            for (const [lang, obj] of Object.entries(inlineResources)) {
+                flat[lang] = flatJSON(obj);
+            }
+            return flat;
+        }
+        if (path)
+            return loadFromPath(path);
+        return {};
+    }, [inlineResources, path]);
+    // Overlay state for mergeLanguage — avoids mutating rawResources so that
+    // setLanguage closures always see the latest language list.
+    const [mergedResources, setMergedResources] = useState(null);
+    const effectiveResources = mergedResources ?? rawResources;
+    const [mergeCounter, setMergeCounter] = useState(0);
+    const languages = useMemo(() => Object.keys(effectiveResources), [effectiveResources, mergeCounter]);
+    const [lang, setLang] = useState(defaultLanguage ?? languages[0] ?? 'en-US');
+    const currentResources = effectiveResources[lang] ?? {};
+    const [defaultCtx, setDefaultCtx] = useState(defaultContext);
+    const t = useCallback((key, options) => {
+        const params = options?.params;
+        const context = options?.context ?? defaultCtx;
+        let value;
+        // Context-aware lookup: first try key.<context>
+        if (context) {
+            const contextKey = `${key}.${context}`;
+            value = currentResources[contextKey];
+            if (value === undefined && fallbackLanguage) {
+                const fb = effectiveResources[fallbackLanguage];
+                if (fb)
+                    value = fb[contextKey];
+            }
+        }
+        // Fall back to the base key if context lookup failed
+        if (value === undefined) {
+            value = currentResources[key];
+            if (value === undefined && fallbackLanguage) {
+                const fb = effectiveResources[fallbackLanguage];
+                if (fb)
+                    value = fb[key];
+            }
+        }
+        if (value === undefined)
+            return key;
+        return interpolate(value, params);
+    }, [currentResources, effectiveResources, fallbackLanguage, defaultCtx]);
+    const setLanguage = useCallback((newLang) => {
+        if (effectiveResources[newLang]) {
+            setLang(newLang);
+        }
+        else {
+            throw new Error(`[Ink-Cartridge] Language "${newLang}" is not available. ` +
+                `Available languages: ${languages.join(', ')}`);
+        }
+    }, [effectiveResources, languages]);
+    const mergeLanguage = useCallback((paths) => {
+        const base = mergedResources ?? rawResources;
+        const merged = { ...base };
+        for (const dirPath of paths) {
+            const incoming = loadFromPath(dirPath);
+            for (const [langCode, flat] of Object.entries(incoming)) {
+                merged[langCode] = { ...(merged[langCode] ?? {}), ...flat };
+            }
+        }
+        setMergedResources(merged);
+        setMergeCounter((n) => n + 1);
+    }, [mergedResources, rawResources]);
+    const setDefaultContext = useCallback((ctx) => { setDefaultCtx(ctx); }, []);
+    const getLanguages = useCallback(() => Object.keys(effectiveResources), [effectiveResources, mergeCounter]);
+    const ctx = useMemo(() => ({ t, setLanguage, setDefaultContext, getLanguages, mergeLanguage, currentLanguage: lang }), [t, setLanguage, getLanguages, mergeLanguage, lang]);
+    return React.createElement(LanguageContext.Provider, { value: ctx }, children);
+}

package/dist/language/types.d.ts

@@ -0,0 +1,124 @@
+import { ReactNode } from 'react';
+/**
+ * Props for the {@link LanguageProvider} component.
+ *
+ * Provide at least one of `resources` (inline translation object) or `path`
+ * (directory of `{locale}.json` files).
+ */
+export interface LanguageProviderProps {
+    /** Child React tree that receives i18n context. */
+    children: ReactNode;
+    /**
+     * Inline translation resources keyed by locale code.
+     *
+     * @example
+     * ```ts
+     * resources={{ 'en-US': { hello: 'Hello' }, 'zh-CN': { hello: '你好' } }}
+     * ```
+     */
+    resources?: Record<string, Record<string, string>>;
+    /**
+     * Path to a directory scanned synchronously for `{locale}.json` files.
+     * Each file becomes one language resource.
+     */
+    path?: string;
+    /** Initial language code. Defaults to the first available locale. */
+    defaultLanguage?: string;
+    /**
+     * Fallback language to try when a key is missing in the current language.
+     * If the key is also missing in the fallback, the key itself is returned.
+     */
+    fallbackLanguage?: string;
+    /**
+     * Default context applied to every `t()` call unless an explicit `context`
+     * option is passed.
+     *
+     * When set, `t('greeting')` behaves as if every call were
+     * `t('greeting', { context: defaultContext })` — it first tries
+     * `key.<defaultContext>`, then falls back to `key`, then to the key itself.
+     *
+     * Can be changed dynamically via the `setDefaultContext` API returned by
+     * `useI18n()`.
+     *
+     * @example
+     * ```tsx
+     * <LanguageProvider defaultContext="male" ...>
+     *   // t('greeting') → looks up 'greeting.male' first
+     * </LanguageProvider>
+     * ```
+     */
+    defaultContext?: string;
+}
+/**
+ * Value provided by {@link LanguageProvider} via React context.
+ * Accessed via the {@link useI18n} hook.
+ */
+export interface I18nContextValue {
+    /**
+     * Translate a key to the current language.
+     *
+     * Dot-separated nested keys are resolved via the flat key map
+     * (e.g. `menu.title` finds the key `"menu.title"` in the JSON).
+     *
+     * @example
+     * // Simple key
+     * t('hello')  →  'Hello'
+     *
+     * // Parameter interpolation
+     * t('welcome', { params: { name: 'Alice' } })  →  'Welcome, Alice'
+     *
+     * // Context-based lookup (e.g. gendered forms)
+     * // Resources: { 'greeting': 'Hello', 'greeting.female': 'Hello, madam' }
+     * t('greeting', { context: 'female' })        →  'Hello, madam'
+     * t('greeting', { context: 'unknown' })        →  'Hello'  (fallback)
+     *
+     * // Context + interpolation
+     * // Resources: { 'welcome.female': 'Welcome, Ms. {name}' }
+     * t('welcome', { context: 'female', params: { name: 'Alice' } })  →  'Welcome, Ms. Alice'
+     *
+     * Missing keys resolve to the key string itself.
+     */
+    t: (key: string, options?: {
+        params?: Record<string, string | number>;
+        context?: string;
+    }) => string;
+    /**
+     * Switch to a different language. Triggers re-render of all consumers.
+     *
+     * @throws {Error} If the requested language is not available, throws
+     *   with a message listing available languages.
+     */
+    setLanguage: (lang: string) => void;
+    /** Returns all available locale codes. */
+    getLanguages: () => string[];
+    /**
+     * Merge translation files from one or more directory paths into the
+     * current resources. Later paths override earlier paths when the same
+     * key exists in multiple sources. Triggers re-render of all consumers.
+     *
+     * Only merges languages whose JSON files exist in the provided paths;
+     * other languages are unaffected.
+     *
+     * @param paths  Array of directory paths, each containing `{locale}.json` files.
+     *               Applied in order: later paths win on key conflicts.
+     */
+    mergeLanguage: (paths: string[]) => void;
+    /**
+     * Dynamically update the default context for all `t()` calls.
+     *
+     * Pass `undefined` to clear the default context, restoring the original
+     * behaviour where only the bare key is looked up.
+     *
+     * @example
+     * ```tsx
+     * setDefaultContext('female');
+     * // All subsequent t() calls now prefer key.<female> first.
+     *
+     * setDefaultContext(undefined);
+     * // Back to bare-key-only lookup.
+     * ```
+     */
+    setDefaultContext: (context?: string) => void;
+    /** Currently active locale code. */
+    currentLanguage: string;
+}

package/dist/language/types.js

@@ -0,0 +1 @@
+export {};

package/dist/screen/ModalContext.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Context that provides the modal ID when rendering inside
+ * a modal component. Null when rendering a regular screen.
+ *
+ * Used by the keyboard system to isolate per-modal keyboard layers
+ * by modal ID instead of component type (enabling multiple instances
+ * of the same component as different modals).
+ *
+ * Architecturally symmetric to {@link OverlayContext}.
+ */
+export declare const ModalContext: import("react").Context<string | null>;

package/dist/screen/ModalContext.js

@@ -0,0 +1,12 @@
+import { createContext } from 'react';
+/**
+ * Context that provides the modal ID when rendering inside
+ * a modal component. Null when rendering a regular screen.
+ *
+ * Used by the keyboard system to isolate per-modal keyboard layers
+ * by modal ID instead of component type (enabling multiple instances
+ * of the same component as different modals).
+ *
+ * Architecturally symmetric to {@link OverlayContext}.
+ */
+export const ModalContext = createContext(null);

package/dist/screen/OverlayContext.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Context that provides the overlay ID when rendering inside
+ * an overlay component. Null when rendering a regular screen.
+ *
+ * Used by the keyboard system to isolate per-overlay keyboard layers
+ * by overlay ID instead of component type (enabling multiple instances
+ * of the same component as different overlays).
+ */
+export declare const OverlayContext: import("react").Context<string | null>;

package/dist/screen/OverlayContext.js

@@ -0,0 +1,10 @@
+import { createContext } from 'react';
+/**
+ * Context that provides the overlay ID when rendering inside
+ * an overlay component. Null when rendering a regular screen.
+ *
+ * Used by the keyboard system to isolate per-overlay keyboard layers
+ * by overlay ID instead of component type (enabling multiple instances
+ * of the same component as different overlays).
+ */
+export const OverlayContext = createContext(null);

package/dist/screen/context.d.ts

@@ -0,0 +1,61 @@
+import { ReactNode } from 'react';
+import type { SkipFn, BackFn, GotoScreenFn, OpenOverlayFn, CloseOverlayFn, CloseAllOverlaysFn, ActivateOverlayFn, DeactivateOverlayFn, OpenModalFn, CloseModalFn, CloseAllModalsFn, OverlayEntry, ModalEntry } from './types.js';
+/**
+ * Value provided by {@link ScenarioManagementProvider} via React context.
+ *
+ * Includes the current screen, all active overlays, navigation functions,
+ * overlay management functions, and modal management functions.
+ */
+export interface ScreenSystemContextValue {
+    /** The rendered React element for the current (top-of-stack) screen. */
+    currentScreen: ReactNode;
+    /** Rendered React elements for all overlays, sorted by zIndex ascending. */
+    currentOverlays: ReactNode[];
+    /** Rendered React elements for all modals, sorted by zIndex ascending. */
+    currentModals: ReactNode[];
+    /** Full navigation path from root to the current screen. */
+    currentPath: React.ComponentType<any>[];
+    /** Navigate down the tree to a direct child of the current screen. */
+    skip: SkipFn;
+    /** Navigate up the tree toward the root. */
+    back: BackFn;
+    /** Jump to any registered screen across branches via LCA resolution. */
+    gotoScreen: GotoScreenFn;
+    /** Open a new overlay with a unique ID. Multiple overlays can coexist. */
+    openOverlay: OpenOverlayFn;
+    /** Close a specific overlay by its ID. */
+    closeOverlay: CloseOverlayFn;
+    /** Close all open overlays at once. */
+    closeAllOverlays: CloseAllOverlaysFn;
+    /** Activate an overlay so it receives keyboard events. */
+    activateOverlay: ActivateOverlayFn;
+    /** Deactivate an overlay so it stops receiving keyboard events. */
+    deactivateOverlay: DeactivateOverlayFn;
+    /** IDs of overlays that are currently active (receiving keyboard events). */
+    activeOverlayIds: string[];
+    /** All currently displayed overlays with metadata (id, zIndex, etc.). */
+    displayedOverlays: OverlayEntry[];
+    /** All open modals with metadata (id, zIndex, etc.), sorted by zIndex ascending. */
+    displayedModals: ModalEntry[];
+    /** The modal entries that correspond to the rendered modal nodes (active + renderNow). Sorted by zIndex ascending. */
+    renderedModalEntries: ModalEntry[];
+    /** ID of the currently active modal (zIndex highest), or null if none. */
+    activeModalId: string | null;
+    /** The currently active modal entry (zIndex highest), or null if none. */
+    activeModal: ModalEntry | null;
+    /** All open modals sorted by zIndex ascending. */
+    modalQueue: ModalEntry[];
+    /** Open a new modal with a unique ID. */
+    openModal: OpenModalFn;
+    /** Close a specific modal by its ID. */
+    closeModal: CloseModalFn;
+    /** Close all open modals at once. */
+    closeAllModals: CloseAllModalsFn;
+}
+/**
+ * React context for the screen navigation system.
+ *
+ * Accessed via {@link useScreenSystem}. Must be provided by a
+ * {@link ScenarioManagementProvider} at the root of the component tree.
+ */
+export declare const ScreenSystemContext: import("react").Context<ScreenSystemContextValue | null>;

package/dist/screen/context.js

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+/**
+ * React context for the screen navigation system.
+ *
+ * Accessed via {@link useScreenSystem}. Must be provided by a
+ * {@link ScenarioManagementProvider} at the root of the component tree.
+ */
+export const ScreenSystemContext = createContext(null);

package/dist/screen/current-screen.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+/**
+ * Render the current screen, overlays, and modals.
+ *
+ * Multiple overlays are rendered in zIndex order (ascending) so higher
+ * zIndex overlays appear on top. Each overlay is wrapped in an
+ * OverlayContext.Provider so the keyboard system can isolate per-overlay
+ * keyboard layers by overlay ID.
+ *
+ * Modals are rendered after overlays so they always appear visually on top.
+ * Each modal is wrapped in a ModalContext.Provider so the keyboard system
+ * can isolate per-modal keyboard layers by modal ID.
+ *
+ * Architecturally symmetric between overlays and modals.
+ */
+export declare function CurrentScreen(): React.ReactNode;

package/dist/screen/current-screen.js

@@ -0,0 +1,38 @@
+import React from 'react';
+import { Box } from 'ink';
+import { useScreenSystem } from './hook.js';
+import { OverlayContext } from './OverlayContext.js';
+import { ModalContext } from './ModalContext.js';
+/**
+ * Render the current screen, overlays, and modals.
+ *
+ * Multiple overlays are rendered in zIndex order (ascending) so higher
+ * zIndex overlays appear on top. Each overlay is wrapped in an
+ * OverlayContext.Provider so the keyboard system can isolate per-overlay
+ * keyboard layers by overlay ID.
+ *
+ * Modals are rendered after overlays so they always appear visually on top.
+ * Each modal is wrapped in a ModalContext.Provider so the keyboard system
+ * can isolate per-modal keyboard layers by modal ID.
+ *
+ * Architecturally symmetric between overlays and modals.
+ */
+export function CurrentScreen() {
+    const { currentScreen, currentOverlays, displayedOverlays, currentModals, renderedModalEntries } = useScreenSystem();
+    // Build overlay elements with OverlayContext wrappers
+    const wrappedOverlays = currentOverlays.map((overlayNode, i) => {
+        const entry = displayedOverlays[i];
+        if (!entry)
+            return overlayNode;
+        return React.createElement(OverlayContext.Provider, { value: entry.id, key: `ovl-ctx-${entry.id}` }, overlayNode);
+    });
+    // Build modal elements with ModalContext wrappers (symmetric to overlays).
+    // Uses renderedModalEntries (parallel to currentModals) for correct ID matching.
+    const wrappedModals = currentModals.map((modalNode, i) => {
+        const entry = renderedModalEntries[i];
+        if (!entry)
+            return modalNode;
+        return React.createElement(ModalContext.Provider, { value: entry.id, key: `mdl-ctx-${entry.id}` }, modalNode);
+    });
+    return React.createElement(Box, { flexDirection: 'column', width: '100%', height: '100%' }, currentScreen, ...wrappedOverlays.map((w) => w), ...wrappedModals.map((w) => w));
+}

package/dist/screen/hook.d.ts

@@ -0,0 +1,13 @@
+import { ScreenSystemContextValue } from './context.js';
+/**
+ * Access the screen-management API from within a React component.
+ *
+ * Returns `{ currentScreen, currentOverlays, currentPath, skip, back,
+ * gotoScreen, openOverlay, closeOverlay, closeAllOverlays, activateOverlay,
+ * deactivateOverlay, activeOverlayIds, displayedOverlays }`.
+ *
+ * Must be used inside a {@link ScenarioManagementProvider}.
+ *
+ * @throws If no provider is found in the component tree.
+ */
+export declare function useScreenSystem(): ScreenSystemContextValue;

package/dist/screen/hook.js

@@ -0,0 +1,20 @@
+import { useContext } from 'react';
+import { ScreenSystemContext } from './context.js';
+/**
+ * Access the screen-management API from within a React component.
+ *
+ * Returns `{ currentScreen, currentOverlays, currentPath, skip, back,
+ * gotoScreen, openOverlay, closeOverlay, closeAllOverlays, activateOverlay,
+ * deactivateOverlay, activeOverlayIds, displayedOverlays }`.
+ *
+ * Must be used inside a {@link ScenarioManagementProvider}.
+ *
+ * @throws If no provider is found in the component tree.
+ */
+export function useScreenSystem() {
+    const ctx = useContext(ScreenSystemContext);
+    if (!ctx) {
+        throw new Error('[Ink-Cartridge] useScreenSystem() must be called inside a <ScenarioManagementProvider>.');
+    }
+    return ctx;
+}

package/dist/screen/index.d.ts

@@ -0,0 +1,7 @@
+export { registerComponent } from './registry.js';
+export { ScenarioManagementProvider, skip, back, gotoScreen, openOverlay, closeOverlay, closeAllOverlays, activateOverlay, deactivateOverlay, openModal, closeModal, closeAllModals, clearDispatchers, } from './provider.js';
+export type { ScenarioManagementProviderProps } from './provider.js';
+export { useScreenSystem } from './hook.js';
+export { CurrentScreen } from './current-screen.js';
+export { ModalContext } from './ModalContext.js';
+export type { SkipOptions, SkipFn, BackFn, GotoScreenFn, OpenOverlayFn, CloseOverlayFn, CloseAllOverlaysFn, ActivateOverlayFn, DeactivateOverlayFn, OpenModalFn, CloseModalFn, CloseAllModalsFn, OpenOverlayOptions, OpenModalOptions, OverlayEntry, ModalEntry, RegisterOptions, } from './types.js';

package/dist/screen/index.js

@@ -0,0 +1,5 @@
+export { registerComponent } from './registry.js';
+export { ScenarioManagementProvider, skip, back, gotoScreen, openOverlay, closeOverlay, closeAllOverlays, activateOverlay, deactivateOverlay, openModal, closeModal, closeAllModals, clearDispatchers, } from './provider.js';
+export { useScreenSystem } from './hook.js';
+export { CurrentScreen } from './current-screen.js';
+export { ModalContext } from './ModalContext.js';