@cratis/stage.runtime 4.219.0 → 4.221.0

package/dist/src/modelReferences.d.ts

@@ -0,0 +1,25 @@
+export type StageModelReferenceKind = 'module' | 'feature' | 'slice' | 'screen';
+/** The identifier the source model gave to one element of a published application. */
+export interface StageModelReference {
+    kind: StageModelReferenceKind;
+    /** The dot-separated qualified name, for example `Shop.Orders.PlaceOrder`. */
+    name: string;
+    id: string;
+}
+/** What a published application knows about its own model, served by `stage/model-references`. */
+export interface StageModelReferences {
+    applicationName: string;
+    publishedName: string;
+    applicationVersion: string;
+    publicationId: string;
+    /** Empty when the source model supplied no identifiers. */
+    references: StageModelReference[];
+    /** Whether the host serves the Notes backend, so the feedback button and its provider are worth rendering. */
+    notesEnabled?: boolean;
+}
+/** Reads the model references of a published application; a sandbox host has none and answers `undefined`. */
+export declare function fetchModelReferences(signal?: AbortSignal, fetcher?: typeof fetch): Promise<StageModelReferences | undefined>;
+/** The identifier the source model gave to the named element, if it gave one. */
+export declare function modelReferenceFor(references: StageModelReferences | undefined, kind: StageModelReferenceKind, name: string): string | undefined;
+/** The model reference map feedback carries: the identifier the source model gave to each element, by its qualified name. */
+export declare function modelReferenceMap(references: StageModelReferences | undefined): Record<string, string>;

package/dist/src/stageNotes.d.ts

@@ -0,0 +1,34 @@
+import type { ApplicationStructure, Screen } from '@cratis/scene.model';
+/** Where a slice sits in the application, the way Arc's `<Slice>` and the Notes context name it. */
+export interface StageSliceLocation {
+    module: string;
+    feature: string;
+    slice: string;
+}
+/** What the host says about feedback: whether Notes is served, and the identifiers of the model's elements by qualified name. */
+export interface StageNotesState {
+    enabled: boolean;
+    modelReferences: Record<string, string>;
+}
+/** Reads the host's feedback state from the model references document; a host without one has Notes off. */
+export declare function readStageNotes(signal: AbortSignal, fetcher?: typeof fetch): Promise<StageNotesState>;
+/** Reads what the host says about Notes once; a host that says nothing (a sandbox) has Notes off. */
+export declare function useStageNotes(): StageNotesState;
+/** Every slice the application knows, for the slice search of the feedback dialog. */
+export declare function knownSlicesOf(structure: ApplicationStructure | undefined): StageSliceLocation[];
+/**
+ * Where the named slice is: by its qualified name (`Module.Feature.Slice`), or by the command it carries. Undefined when the structure does not
+ * contain it.
+ */
+export declare function locateSlice(structure: ApplicationStructure | undefined, nameOrCommand: string | undefined): StageSliceLocation | undefined;
+/**
+ * Where a screen is: its module and feature from the ancestry the model recorded, and the slice it shows when the structure has a slice of the
+ * screen's name there. A screen without ancestry is somewhere in the application without a module or feature.
+ */
+export declare function locateScreen(structure: ApplicationStructure | undefined, screen: Screen | undefined): StageSliceLocation | undefined;
+/** What Arc's application context is told about the screen being shown: its identity and the module and feature ancestry it sits in. */
+export declare function screenContribution(screen: Screen | undefined): {
+    id: string;
+    name: string;
+    path: string;
+} | undefined;

package/dist/src/stageSource.d.ts

@@ -2,12 +2,15 @@ import { type ReactNode } from 'react';
 import type { StringsDictionary } from '@cratis/scene.engine';
 import type { StageRoutes } from './stageRoutes';
 import type { StageSceneApplication } from './App';
+import type { StageNotesState } from './stageNotes';
 /** 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 the host says about feedback: whether Notes is served, and the model references. A source with nothing to say omits it. */
+    notes?(signal: AbortSignal): Promise<StageNotesState>;
 }
 /** What a generated application already holds when it is built. */
 export interface StageStaticContent {
@@ -22,6 +25,7 @@ export declare const stageEndpoints: {
     scene: string;
     routes: string;
     locales: string;
+    modelReferences: string;
     strings: (locale: string) => string;
 };
 /** Supplies the source the runtime below reads from. Transport belongs to the host. */

package/dist/src/stageStructure.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from 'react';
+import type { ApplicationStructure, Screen } from '@cratis/scene.model';
+interface StageStructure {
+    structure?: ApplicationStructure;
+    screens: Screen[];
+}
+/** Gives the screens and dialogs below the structure of the application, so they can declare which slice they are. */
+export declare function StageStructureProvider({ structure, screens, children }: StageStructure & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Declares the slice a screen shows, so the markers and the application context know where the user is. */
+export declare function ScreenSlice({ screen, children }: {
+    screen: string | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Declares the slice a dialog was opened for, named by its qualified name or by its command. */
+export declare function DialogSlice({ slice, children }: {
+    slice: string | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratis/stage.runtime",
-  "version": "4.219.0",
+  "version": "4.221.0",
   "description": "The Cratis Stage application runtime for Arc and Scene",
   "author": "Cratis",
   "type": "module",
@@ -41,19 +41,21 @@
     "test": "vitest run"
   },
   "peerDependencies": {
-    "@cratis/arc": "22.146.0",
-    "@cratis/arc.react": "22.146.0",
-    "@cratis/components": "4.38.1",
-    "@cratis/fundamentals": "7.27.1",
-    "@cratis/scene.blueprint.default": "4.87.0",
-    "@cratis/scene.components": "4.87.0",
-    "@cratis/scene.engine": "4.87.0",
-    "@cratis/scene.model": "4.87.0",
-    "@cratis/scene.primereact": "4.87.0",
-    "@cratis/scene.react": "4.87.0",
+    "@cratis/arc": "22.166.1",
+    "@cratis/arc.react": "22.166.1",
+    "@cratis/components": "4.40.0",
+    "@cratis/fundamentals": "7.33.1",
+    "@cratis/scene.blueprint.default": "4.88.0",
+    "@cratis/scene.components": "4.88.0",
+    "@cratis/scene.engine": "4.88.0",
+    "@cratis/scene.model": "4.88.0",
+    "@cratis/scene.primereact": "4.88.0",
+    "@cratis/scene.react": "4.88.0",
+    "@cratis/showrunner.notes": "1.0.0",
+    "@cratis/showrunner.notes.react": "1.0.0",
     "@primereact/ui": "11.2.2",
-    "@primeuix/themes": "3.0.1",
-    "lucide-react": "1.52.0",
+    "@primeuix/themes": "3.1.0",
+    "lucide-react": "1.68.0",
     "primereact": "11.2.2",
     "react": "19.3.1",
     "react-dom": "19.3.1",
@@ -79,10 +81,10 @@
     "@types/node": "26.6.6",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
-    "@vitejs/plugin-react": "6.1.2",
+    "@vitejs/plugin-react": "6.2.1",
     "jsdom": "30.1.3",
     "react-dom": "19.3.1",
     "typescript": "6.0.3",
-    "vitest": "5.0.5"
+    "vitest": "5.1.0"
   }
 }