@cratis/stage.runtime 0.0.0 → 4.157.0

package/dist/src/navigationTree.d.ts

@@ -0,0 +1,69 @@
+import type { DestinationReference, Screen } from '@cratis/scene.model';
+/** The contribution point the application's navigation is contributed to. */
+export declare const navigationContributionPoint = "Navigation";
+/** One authored navigation entry: what it is called, the screen it opens and where in the application it was declared. */
+export interface NavigationEntry {
+    label: string;
+    targetScreen: string;
+    /** The module and features, outermost first, the entry was declared in. */
+    hierarchy: string[];
+    order?: number;
+    /** The icon the entry was authored with. */
+    icon?: string;
+    /** How chrome shows the entry - `icon`, `text` or `both`; any other value is a hint the theme may read. */
+    presentation?: string;
+    /** Where the entry opens when that is not simply the screen: an outlet, a dialog or an external route. */
+    destination?: DestinationReference;
+}
+/** A node of the navigation tree: a group (module or feature) with children, or an entry that opens a screen. */
+export interface NavigationNode {
+    label: string;
+    /** The screen the node opens; absent on a group. */
+    screen?: string;
+    icon?: string;
+    presentation?: string;
+    destination?: DestinationReference;
+    children: NavigationNode[];
+}
+/**
+ * The navigation the model authored: every `Navigation` contribution on any screen, once.
+ *
+ * A feature's contribution is attached to every screen of the feature, so the same entry arrives several times;
+ * an entry is the same when it opens the same screen from the same place under the same label.
+ *
+ * @param screens The scene's screens.
+ * @returns The authored entries, in the order the model gave them (ordered ones first, by `order`).
+ */
+export declare function authoredNavigationEntries(screens: Screen[]): NavigationEntry[];
+/**
+ * Lays the entries out as the application hierarchy the model declared: a group per module and per feature,
+ * nested as deep as the model nests them, with each entry under the feature it was declared in. Groups and
+ * entries keep the order of the entries, so an ordered entry orders the group it sits in.
+ *
+ * @param entries The authored entries.
+ * @returns The top-level nodes.
+ */
+export declare function navigationTree(entries: NavigationEntry[]): NavigationNode[];
+/**
+ * The labels leading to a screen in the tree - each group, then the entry - for the breadcrumb.
+ *
+ * @param nodes The navigation tree.
+ * @param screen The screen to find.
+ * @returns The labels from the outermost group to the entry, or an empty list when no entry opens the screen.
+ */
+export declare function navigationPathTo(nodes: NavigationNode[], screen: string): string[];
+/** Whether an entry opens somewhere a plain link to its screen does not reach: an outlet, a dialog or an external route. */
+export declare function opensElsewhere(destination: DestinationReference): boolean;
+/**
+ * The hierarchy the screens declare, for the screens no navigation entry lists.
+ *
+ * A screen records the modules and features it was declared in, so one the model gave no entry still has a place:
+ * under its own module and feature, beside the entries that do list screens there. A screen declared outside any
+ * module has no place to be under, and goes with the other screens that have none.
+ *
+ * @param screens The scene's screens.
+ * @param listed The names of the screens an authored entry opens.
+ * @param fallback The group a screen with no recorded place goes under.
+ * @returns One entry for every unlisted screen, labelled with its own name.
+ */
+export declare function unlistedNavigationEntries(screens: Screen[], listed: ReadonlySet<string>, fallback: string): NavigationEntry[];

package/dist/src/stageComponents.d.ts

@@ -0,0 +1,31 @@
+import type { ExternalComponent, SceneElement } from '@cratis/scene.model';
+import type { InteractionHandlers } from '@cratis/scene.react';
+import type { ComponentType, ReactNode } from 'react';
+import { StageCommandForm } from './StageCommandForm';
+export declare const stageCommandFormComponent = "Stage:commandForm";
+interface RegisteredProps {
+    element: ExternalComponent;
+    slots: Record<string, ReactNode[]>;
+    interactions?: InteractionHandlers;
+}
+/**
+ * Reads a slice's read model through the query the Stage registered for it.
+ *
+ * A table the model says navigates on a row click (`navigate to WorkItemDetails by workItemId`) carries that
+ * parameter in the address: clicking a row on another screen navigates there with the row's identity, clicking a
+ * row on the target screen itself updates the parameter in place, and opening an address that already carries it
+ * selects the row it names. The parameter is then what every query and command on the screen is scoped by.
+ */
+export declare function StageTable({ element, slots }: RegisteredProps): import("react").JSX.Element;
+/** Renders an authored screen form bound to a modeled command. */
+export { StageCommandForm };
+/** Executes a modeled command against the route the Stage registered for it. */
+export declare function StageAction({ element, interactions, slots }: RegisteredProps): import("react").JSX.Element;
+/**
+ * The components the Stage renders a scene with: Scene's own core vocabulary, with the two that have to reach
+ * this running application - the table that reads a modeled query, and the action that executes a modeled
+ * command - replaced by versions that do.
+ */
+export declare const stageComponents: Record<string, ComponentType<RegisteredProps>>;
+/** Whether an element tree contains anything the Stage can act on. */
+export declare function isActionable(element: SceneElement): boolean;

package/dist/src/stageData.d.ts

@@ -0,0 +1,72 @@
+import type React from 'react';
+import type { BindingExpression } from '@cratis/scene.model';
+import type { StageRoutes } from './stageRoutes';
+interface QueryState {
+    name?: string;
+    route: string;
+    rows: Record<string, unknown>[];
+    loading: boolean;
+    error: string;
+    arguments: Record<string, unknown>;
+}
+export interface StageQueryRequest {
+    scope: string;
+    name?: string;
+    route?: string;
+    arguments?: Record<string, unknown>;
+    ready?: boolean;
+    /**
+     * Whether the result is published to the screen's bindings. A query read only to decide something - the item a
+     * guard is evaluated against - is not, so it does not show up twice where the screen reads the same query.
+     */
+    publish?: boolean;
+}
+export interface StageQueryResult {
+    rows: Record<string, unknown>[];
+    loading: boolean;
+    error: string;
+    refresh: () => void;
+}
+export interface StageDataState {
+    locale: string;
+    locales: string[];
+    screen: string;
+    routes: StageRoutes | undefined;
+    routesReady: boolean;
+    parameters: Record<string, string>;
+    queries: Record<string, QueryState>;
+    selected: Record<string, unknown> | undefined;
+    selections: Record<string, Record<string, unknown> | undefined>;
+    selectRow: (scope: string, row: Record<string, unknown> | undefined) => void;
+    clearSelection: (scope: string) => void;
+    setState: (key: string, value: unknown) => void;
+    setComponentOutput: (componentId: string, path: string, value: unknown) => void;
+    refreshQuery: (query?: string) => void;
+    refreshAfterCommand: () => void;
+    resolveBinding: (binding: BindingExpression | string | undefined) => unknown;
+    /**
+     * Resolves a command argument source the way Scene does: `component.<id>.<output>` reads what another
+     * element publishes - such as the `value` an input holds or a table's `selectedItem` - and any other
+     * source is a data-context path.
+     */
+    resolveArgument: (source: string | undefined) => unknown;
+    registerQueryResult: (scope: string, state: QueryState | undefined) => void;
+    refreshVersion: number;
+    refreshQueryName?: string;
+}
+/** When, after a command's own refresh, its queries are read again so an asynchronous projection has caught up. */
+export declare const commandSettleDelays: number[];
+export interface StageDataProviderProps {
+    routes: StageRoutes | undefined;
+    routesReady?: boolean;
+    parameters?: Record<string, string>;
+    locale: string;
+    locales: string[];
+    screen: string;
+    children: React.ReactNode;
+}
+export declare function StageDataProvider({ routes, routesReady, parameters, locale, locales, screen, children }: StageDataProviderProps): React.JSX.Element;
+export declare const useStageData: () => StageDataState;
+export declare function useStageQuery(request: StageQueryRequest): StageQueryResult;
+export declare function dataChanged(): void;
+export {};

package/dist/src/stageDataSources.d.ts

@@ -0,0 +1,17 @@
+import type { SceneElement } from '@cratis/scene.model';
+/** The component a modeled `data` declaration is rendered as. */
+export declare const dataComponent = "core:data";
+/**
+ * Connects every table to the modeled `data` declaration that feeds it.
+ *
+ * A screen declares its data once - `data CommentsForWorkItem by workItemId` - and the table that follows it in
+ * the same section, or any section nested after it, shows that read model. The table itself only names the read
+ * model type, so without this it would read the unfiltered collection: every comment of every work item. This
+ * carries the declaration's query and its `by` parameter onto the table, bound to the screen parameter of the
+ * same name, so the table reads only what the declaration asked for and reads nothing while that parameter has
+ * no value.
+ *
+ * @param element The composed screen.
+ * @returns The screen with every fed table bound to its declaration.
+ */
+export declare function bindDataSources(element: SceneElement): SceneElement;

package/dist/src/stageGuards.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Evaluates the guards a Screenplay `when ... otherwise` carries.
+ *
+ * A guard compares a field of the subject - `item`, the record the nearest `data` declaration reads, or the row an
+ * interaction happened on - with a literal, and combines comparisons with `and` and `or`. That is the whole guard
+ * language Screenplay admits, and the same shape Stage emits into the Scene for a guarded action and for a guarded
+ * interaction. Anything else is not evaluable: the answer is then `undefined`, never `true`, so a guard the runtime
+ * does not understand can never let a command through.
+ */
+/** The binding path a guarded interaction binding's condition carries; its `value` is a {@link GuardSelection}. */
+export declare const guardPath = "$guard";
+/** One condition of a guard. */
+export type GuardCondition = ComparisonCondition | LogicalCondition;
+/**
+ * A field of the guard's subject, such as `{ subject: 'item.status' }`.
+ *
+ * It is deliberately not a binding: Scene resolves every `{ path }` object in a component's properties against the
+ * data context before the component renders, which would replace the reference with a value. A `path` is still read,
+ * for guards written directly as Scene JSON or carried where Scene does not resolve them.
+ */
+export interface SubjectReference {
+    subject?: string;
+    path?: string;
+}
+/**
+ * Reads the subject path a reference names.
+ * @param reference The reference.
+ * @returns The path, or `undefined` when it names none.
+ */
+export declare function subjectPath(reference: unknown): string | undefined;
+/** Compares a field of the subject with a literal. */
+export interface ComparisonCondition {
+    kind: 'comparison';
+    left: SubjectReference;
+    operator: string;
+    right: unknown;
+    /** The members of the enumeration the field is, in declared order, when it is one. */
+    enumeration?: string[];
+}
+/** Combines two conditions. */
+export interface LogicalCondition {
+    kind: 'logical';
+    left: GuardCondition;
+    operator: string;
+    right: GuardCondition;
+}
+/**
+ * Which branch of an ordered first-match guard a binding is: alternative `index`, or the `otherwise` that runs when
+ * there is a subject and no alternative holds.
+ */
+export interface GuardSelection {
+    kind: 'firstMatch' | 'otherwise';
+    index?: number;
+    alternatives: unknown[];
+}
+/** The diagnostic a guard the runtime cannot evaluate is reported with. */
+export declare const unevaluableGuardCode = "STAGE-SCENE-ACTION-001";
+/**
+ * Evaluates one condition against a subject.
+ *
+ * A missing or null field does not match - `item.status == "open"` is false for an item without a status - because
+ * that is what Screenplay specifies and because the alternative, matching on absence, would run a command against
+ * data that never said it could.
+ *
+ * @param condition The condition as the Scene carries it.
+ * @param subject The record the condition is about.
+ * @returns Whether it holds, or `undefined` when it is not a condition this runtime can evaluate.
+ */
+export declare function evaluateCondition(condition: unknown, subject: Record<string, unknown>): boolean | undefined;
+/** Whether every condition can be evaluated, independently of any subject. */
+export declare function canEvaluate(conditions: unknown[]): boolean;
+/**
+ * Picks the first alternative whose condition holds.
+ * @param conditions The alternatives' conditions, in authored order.
+ * @param subject The record they are about.
+ * @returns The index of the first that holds, -1 when none does, or `undefined` when any is not evaluable.
+ */
+export declare function firstMatch(conditions: unknown[], subject: Record<string, unknown>): number | undefined;
+/**
+ * Resolves a guarded interaction binding's condition: whether its branch is the one that runs for this subject.
+ * @param selection The {@link GuardSelection} the binding carries.
+ * @param subject The record the interaction is about, when there is one.
+ * @returns Whether the branch runs, or `undefined` when there is no subject or the guard is not evaluable - which
+ * the interaction engine reports and treats as not running.
+ */
+export declare function resolveGuard(selection: unknown, subject: unknown): boolean | undefined;
+/** Resolves a binding path against a subject, for paths that start with `item.`. */
+export declare function subjectValue(path: string, subject: unknown): unknown;

package/dist/src/stageNavigation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The parameters a screen was navigated to with, read from the hash (`#/WorkItemDetails?workItemId=...`).
+ *
+ * A modeled table that navigates on a row click names the parameter it navigates by. Keeping that parameter in
+ * the address is what makes the selection a deep link: reloading, sharing or reopening the address selects the
+ * same row and re-runs the queries that depend on it.
+ *
+ * @param hash The location hash.
+ * @returns The parameters, by name.
+ */
+export declare function screenParameters(hash: string): Record<string, string>;
+/**
+ * The hash addressing a screen with the given parameters.
+ *
+ * @param screen The screen name.
+ * @param parameters The parameters to carry; empty values are left out.
+ * @returns The hash.
+ */
+export declare function screenHashWith(screen: string, parameters?: Record<string, string>): string;
+/**
+ * Navigates to a screen with parameters through the address, so the application, history and a reload agree.
+ *
+ * @param screen The screen name.
+ * @param parameters The parameters to carry.
+ */
+export declare function navigateToScreen(screen: string, parameters?: Record<string, string>): void;
+/**
+ * Turns an interaction's navigation arguments into screen parameters: every argument with a value, as text, the way
+ * it appears in the address. An argument without a value is left out rather than written as `undefined`.
+ * @param args The arguments the navigation was given.
+ * @returns The screen parameters.
+ */
+export declare function screenArguments(args: Record<string, unknown> | undefined): Record<string, string>;

package/dist/src/stageNavigationModel.d.ts

@@ -0,0 +1,22 @@
+import type { ApplicationStructure, NavigationModel, Screen } from '@cratis/scene.model';
+import type { EffectiveNavItem } from '@cratis/scene.engine';
+import type { SceneNavigationModel } from '@cratis/scene.react';
+/** Whether the model declares navigation regions of its own - the application's or a module's. */
+export declare function declaresRegions(navigation: NavigationModel | undefined): boolean;
+/**
+ * The screen a navigation item opens: the screen declared in the feature the item resolves to (a screen's `path` is the modules and
+ * features it was declared in), the first screen declared beneath it, or the screen named like the feature - which is how the
+ * application structure names a feature's screen.
+ */
+export declare function stageScreenFor(screens: Screen[]): (item: EffectiveNavItem) => string | undefined;
+/** The module a screen was declared in - the first of its `path` - which decides whose sidebar the page shows. */
+export declare function stageModuleOf(screens: Screen[]): (screen: string | undefined) => string | undefined;
+/**
+ * What Scene's navigation regions read: the model's structure and navigation, and the two hooks that are the host's - where an item
+ * goes and which items the user may see. Hidden is hidden, never disabled, so nothing about an item the user may not see leaks.
+ */
+export declare function stageNavigationModel(scene: {
+    screens: Screen[];
+    navigation?: NavigationModel;
+    structure?: ApplicationStructure;
+}, isVisible?: (item: EffectiveNavItem) => boolean): SceneNavigationModel;

package/dist/src/stageRoutes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Where the running application registered its modeled commands and queries.
+ */
+export interface StageRoutes {
+    commands: Record<string, string>;
+    queries: Record<string, string>;
+    /** Live-host metadata for route-synthesized proxies. Generated apps register their real proxies instead. */
+    commandSchemas?: Record<string, string>;
+}
+export interface StageRouteState {
+    routes: StageRoutes | undefined;
+    ready: boolean;
+}
+export declare const stageRoutes: string;
+/**
+ * Reads the routes the Stage registered and says when that lookup has finished.
+ *
+ * An element carries the route it is backed by, but an interaction only names a command - so running one needs
+ * this lookup. Readiness is separate from the routes object because an empty or failed route lookup is a real
+ * loaded state; guessing a URL while it is still pending would turn a valid command into a transient 404.
+ */
+export declare function useStageRouteState(): StageRouteState;
+/** Reads the routes the Stage registered. */
+export declare function useStageRoutes(): StageRoutes | undefined;

package/dist/src/stageRowInteractions.d.ts

@@ -0,0 +1,26 @@
+import type { ExternalComponent } from '@cratis/scene.model';
+/** How long a row waits for a second click before treating the first as a single click. */
+export declare const doubleClickWindow = 250;
+/** What a table does with clicks on its rows. */
+export interface RowInteractions {
+    /** Handles a click: at once, or after the double-click window when the table also handles double clicks. */
+    click: (row: Record<string, unknown>, single: () => void) => void;
+    /** Handles a double click, when the table declares one; otherwise `undefined`. */
+    doubleClick?: (row: Record<string, unknown>) => void;
+}
+/**
+ * Runs a table's `on double click` bindings for the row that was double clicked.
+ *
+ * The bindings are the table's own, resolved and run by the Scene interaction engine - the same engine that runs
+ * every other interaction - with `item` meaning the row. A guarded `when ... otherwise` arrives as one binding per
+ * branch whose condition the engine resolves through this context, so exactly the first branch that holds for the
+ * row runs, and the `otherwise` branch runs when none does.
+ *
+ * A row's single click (selection, or navigation to the row) would otherwise always win the race with a double
+ * click, because a double click starts with a click. When the table declares a double click, a single click waits
+ * out the double-click window first and is cancelled by the double click.
+ *
+ * @param element The table.
+ * @returns The row handlers.
+ */
+export declare function useRowInteractions(element: ExternalComponent): RowInteractions;

package/dist/src/stageShell.d.ts

@@ -0,0 +1,55 @@
+import { type Theme, type UiProfile } from '@cratis/scene.model';
+import { type EffectiveShell } from '@cratis/scene.engine';
+import { ColorScheme, LayoutMode, MenuTheme } from '@cratis/scene.blueprint.default';
+/** What the profile's root template, shell options and appearance ask of the running shell. */
+export interface StageShellSettings {
+    /** The sidebar mode the profile's `navigationMode` option names. */
+    mode?: LayoutMode;
+    /** How the sidebar is tinted, when the profile's `menuTheme` option names one. */
+    menuTheme?: MenuTheme;
+    /** Whether the shell draws its footer; the `showFooter` option, drawn unless it is `false`. */
+    showFooter: boolean;
+    /** The theme the colour scheme selects, by name. */
+    themeName?: string;
+    /** The colour scheme the sidebar and the page follow. */
+    colorScheme?: ColorScheme;
+    /** Whether the profile follows the operating system's scheme instead of fixing one. */
+    followsSystem: boolean;
+    /** The accent colour, as the profile wrote it. */
+    accent?: string;
+    /** Options and values the shell does not understand: stated, never silently dropped. */
+    problems: string[];
+}
+/** The shell options the default blueprint's shells expose; any other name is stated as a problem. */
+export declare const knownShellOptions: readonly string[];
+/**
+ * Reads the profile's shell options and appearance into what the running shell is told to do.
+ *
+ * The effective shell is the engine's answer (`resolveEffectiveShell`); this only maps its options and the profile's
+ * appearance onto the blueprint's layout configuration, so the Stage and the Scene preview start a shell the same way.
+ *
+ * @param profile The profile the application renders with.
+ * @param shell The effective shell the engine resolved for it.
+ * @param prefersDark Whether the operating system prefers a dark scheme, for a profile that follows the system.
+ * @returns The settings, with every option or value that could not be applied.
+ */
+export declare function stageShellSettings(profile: UiProfile | undefined, shell: EffectiveShell, prefersDark?: boolean): StageShellSettings;
+/**
+ * What stops an application starting with the root template its profile names: the template is unknown, its blueprint is not
+ * installed, its version pin is not satisfied or it cannot be a shell. A page that cannot be drawn in the shell it asked for
+ * is stated, not drawn in a different one.
+ *
+ * @param profile The profile the application renders with.
+ * @param shell The effective shell the engine resolved for it.
+ * @returns The problems, empty when the root template resolved or the profile names none.
+ */
+export declare function shellStartupProblems(profile: UiProfile | undefined, shell: EffectiveShell): string[];
+/**
+ * The themes with the profile's accent set as their primary colour. Without an accent the themes are returned as they are, so
+ * the theme keeps its own.
+ *
+ * @param themes The themes the shell offers.
+ * @param accent The accent colour, `#rgb` or `#rrggbb`.
+ * @returns The themes to give the shell.
+ */
+export declare function themesWithAccent(themes: Theme[], accent: string | undefined): Theme[];

package/dist/src/stageSlices.d.ts

@@ -0,0 +1,21 @@
+import type { SliceCommandField, SliceInvoker } from '@cratis/scene.react';
+import type { StageCommandOutcome } from './StageCommandOutcome';
+/**
+ * The fields of a command, for the task dialog a toolbar slice button opens. They are what the command's schema declares -
+ * the same reading the native command form uses - so the dialog asks for exactly what the command takes. A property the form
+ * cannot present (a collection, an object) is left out rather than shown as a field that cannot be filled.
+ *
+ * @param schemas The JSON schema of every modeled command, by command name.
+ * @returns The fields of a command; none for a command the application does not describe.
+ */
+export declare function sliceFieldsFrom(schemas: Record<string, string> | undefined): (command: string) => SliceCommandField[];
+/**
+ * The invoker the running application submits a task dialog through: the command is posted to the route the Stage registered for
+ * it, exactly as an action or a form posts it, and the application's own validation results come back to the dialog against the
+ * fields they name. A successful command refreshes what the screen shows.
+ *
+ * @param executeCommand Executes a registered Arc proxy with the host's configuration.
+ * @param routesReady Whether the lookup has finished, so a command with no route is not-registered rather than not-yet.
+ * @param refreshAfterCommand Called after a command succeeds.
+ */
+export declare function createStageSliceInvoker(executeCommand: (name: string, values: Record<string, unknown>) => Promise<StageCommandOutcome>, routesReady: boolean, refreshAfterCommand: () => void): SliceInvoker;

package/dist/src/stageSource.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+import type { StringsDictionary } from '@cratis/scene.engine';
+import type { StageRoutes } from './stageRoutes';
+import type { StageSceneApplication } from './App';
+/** The content supplied by the host of a Stage application. */
+export interface StageSource {
+    scene(signal: AbortSignal): Promise<StageSceneApplication>;
+    routes(signal: AbortSignal): Promise<StageRoutes | undefined>;
+    locales(signal: AbortSignal): Promise<string[]>;
+    strings(locale: string, signal: AbortSignal): Promise<StringsDictionary>;
+}
+/** What a generated application already holds when it is built. */
+export interface StageStaticContent {
+    scene: StageSceneApplication;
+    routes: StageRoutes;
+    strings: Record<string, StringsDictionary>;
+}
+/** Serves the document, routes and dictionaries built into an application. */
+export declare function staticStageSource(content: StageStaticContent): StageSource;
+/** Relative endpoint names shared with the live host's transport. */
+export declare const stageEndpoints: {
+    scene: string;
+    routes: string;
+    locales: string;
+    strings: (locale: string) => string;
+};
+/** Supplies the source the runtime below reads from. Transport belongs to the host. */
+export declare function StageSourceProvider({ source, children }: {
+    source: StageSource;
+    children?: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<StageSource | undefined>>;
+/** The source the runtime reads from. */
+export declare function useStageSource(): StageSource;

package/dist/src/stageTheme.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The selector that puts PrimeReact in its dark scheme: the colour scheme the active blueprint theme sets on
+ * the document root (see `ColorSchemeMirror`), so a dialog portalled to `body` follows the shell.
+ */
+export declare const stageDarkSelector = "[data-scene-color-scheme='dark']";
+/**
+ * The PrimeReact theme a Stage application renders with.
+ *
+ * PrimeReact 11 ships no CSS of its own: a component is styled only when the provider above it is handed a
+ * theme preset, from which it injects its styles at runtime. Without one, every component still renders its
+ * markup - a dialog included - but with nothing positioning or painting it, so a command's dialog opened as
+ * unstyled content below the screen and a user saw nothing happen when they clicked the command's button.
+ */
+export declare const stageTheme: {
+    preset: import("@primeuix/themes/types").Preset<import("@primeuix/themes/types/base").BaseDesignTokens>;
+    options: {
+        darkModeSelector: string;
+    };
+};

package/dist/src/useStrings.d.ts

@@ -0,0 +1,21 @@
+import type { StringsDictionary } from '@cratis/scene.engine';
+export interface Strings {
+    /** Every locale at least one `.strings` file next to the model declares. */
+    locales: string[];
+    /** The active locale, or an empty string before the first `/stage/locales` fetch resolves. */
+    locale: string;
+    /** Switches the active locale, triggering a fetch of its dictionary. */
+    setLocale: (locale: string) => void;
+    /** The active locale's merged dictionary - empty until its fetch resolves. */
+    dictionary: StringsDictionary;
+}
+/**
+ * Fetches the locales a running Stage's `.strings` files declare, then the active one's dictionary -
+ * resolution itself (turning a dictionary and a tree into a resolved one) is `resolveStringsInElement`
+ * from `@cratis/scene.engine`; this only owns getting a dictionary from the network in the first place.
+ *
+ * The first locale `/stage/locales` reports becomes the default - there is no configured "default locale"
+ * concept yet, so the model deciding which `.strings` file exists first (alphabetically, since
+ * `IStringsFiles.FindIn` orders by relative path) is what a running Stage actually offers today.
+ */
+export declare function useStrings(): Strings;

package/dist/styledPrimeReact.d.ts

@@ -0,0 +1,23 @@
+import type { Plugin } from 'vite';
+/**
+ * Serves PrimeReact's styled components wherever its unstyled primitives are imported.
+ *
+ * `primereact/<component>` is PrimeReact 11's headless layer: it renders the markup but carries no styles, so
+ * nothing positions or paints it. The styled components - the same API with their style modules applied - live
+ * in `@primereact/ui/<component>`. The Scene components Stage renders with (`@cratis/scene.primereact`) import
+ * the primitives, which left a Stage application's buttons as bare text and a command's dialog rendered as plain
+ * content below the screen, where the user never saw it open.
+ *
+ * An import of a primitive from outside PrimeReact therefore gets a module that re-exports everything the
+ * primitive does, with every name `@primereact/ui` also exports taken from there instead. The styled package
+ * does not cover every helper a primitive exports, which is why it cannot simply replace the primitive.
+ * PrimeReact's own packages are built on the primitives - `@primereact/ui` wraps them and the primitives import
+ * one another - so imports from inside PrimeReact are left alone.
+ */
+export declare function styledPrimeReact(): Plugin;
+/**
+ * Reads the names a bundled ES module exports from its `export { ... }` statements.
+ * @param source The module source.
+ * @returns The exported names.
+ */
+export declare function exportedNames(source: string): string[];

package/dist/styledPrimeReact.js

@@ -0,0 +1,30 @@
+import { readFile as e } from "node:fs/promises";
+//#region styledPrimeReact.ts
+var t = /^primereact\/([a-z]+)$/, n = "\0stage-styled-primereact:";
+function r() {
+	return {
+		name: "stage-styled-primereact",
+		enforce: "pre",
+		resolveId(e, r) {
+			let i = t.exec(e);
+			return !i || !r || r.startsWith(n) || /\/node_modules\/(primereact|@primereact)\//.test(r) ? null : `${n}${i[1]}`;
+		},
+		async load(t) {
+			if (!t.startsWith(n)) return null;
+			let r = t.slice(25), a = await this.resolve(`@primereact/ui/${r}`, void 0, { skipSelf: !0 });
+			if (!a) return `export * from 'primereact/${r}';`;
+			let o = i(await e(a.id, "utf8"));
+			return [`export * from 'primereact/${r}';`, o.length > 0 ? `export { ${o.join(", ")} } from '@primereact/ui/${r}';` : ""].join("\n");
+		}
+	};
+}
+function i(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e.matchAll(/export\s*\{([^}]*)\}/g)) for (let e of n[1].split(",")) {
+		let n = e.trim().split(/\s+as\s+/).pop()?.trim();
+		n && n !== "default" && t.add(n);
+	}
+	return [...t];
+}
+//#endregion
+export { i as exportedNames, r as styledPrimeReact };