@cratis/stage.runtime 4.216.1 → 4.218.0

package/dist/src/screenplayGuard.d.ts

@@ -0,0 +1,11 @@
+import { runBindings } from '@cratis/scene.engine';
+/** Runs every Stage-owned interaction through Screenplay admission before native Scene selection. */
+export declare function runScreenplayBindings(...[bindings, dispatcher, context]: Parameters<typeof runBindings>): ReturnType<typeof runBindings>;
+/** Restricts native Scene guards to Screenplay's string-only contains contract before branch selection. */
+export declare function screenplayGuard<Condition>(condition: Condition, item: unknown): Condition;
+/** Applies the same admission rule to every alternative, including those native selection would not reach. */
+export declare function screenplayGuardAlternatives(alternatives: unknown, item: unknown): unknown;
+/** Restricts a binding without changing its native Scene sequencing or fallback actions. */
+export declare function screenplayGuardBinding<Binding extends {
+    alternatives?: unknown;
+}>(binding: Binding, item: unknown): Binding;

package/dist/src/stageActionSubject.d.ts

@@ -18,6 +18,8 @@ export interface SubjectForm extends ScreenRows {
 }
 /** The explicit subject an action element names, or nothing when the subject was omitted. */
 export declare function actionSubjectOf(element: ExternalComponent): ActionSubject | undefined;
+/** Semantic schema intent beats advisory row/creation hints; explicit subjects retain their own binding semantics. */
+export declare function actionCreatesEntity(element: ExternalComponent, schema: string | undefined): boolean;
 /** The one selected row an `item` subject acts on; no subject, a `screen` subject and two or more selected rows name none. */
 export declare function subjectRowOf(subject: ActionSubject | undefined, selectedRows: Record<string, unknown>[]): Record<string, unknown> | undefined;
 /** Whether an action waits, visible and disabled: a `for item` action without its one selected row. */

package/dist/src/stageData.d.ts

@@ -1,6 +1,14 @@
 import type React from 'react';
-import type { BindingExpression } from '@cratis/scene.model';
+import { type BindingExpression } from '@cratis/scene.model';
 import type { StageRoutes } from './stageRoutes';
+import { type RegisteredComponentProps } from '@cratis/scene.react';
+import type { ExternalComponent } from '@cratis/scene.model';
+/** Whether the component uses Scene's guarded-action contract. */
+export declare function isGuardedAction(element: ExternalComponent): boolean;
+/** Supplies Stage's nearest-data subject to Scene; Scene alone selects and executes the branch. */
+export declare function StageSceneGuardedAction(props: Omit<RegisteredComponentProps, 'slots'> & {
+    slots?: RegisteredComponentProps['slots'];
+}): React.JSX.Element;
 interface QueryState {
     name?: string;
     /** The read model's name, under which the rows are published to the binding scope as well - where a summary looks them up. */

package/dist/src/stageRowInteractions.d.ts

@@ -12,9 +12,8 @@ export interface RowInteractions {
  * 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.
+ * every other interaction - with the subject meaning the row. Scene selects the first matching alternative
+ * and runs the otherwise actions only when none match.
  *
  * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratis/stage.runtime",
-  "version": "4.216.1",
+  "version": "4.218.0",
   "description": "The Cratis Stage application runtime for Arc and Scene",
   "author": "Cratis",
   "type": "module",
@@ -44,19 +44,19 @@
     "@cratis/arc": "22.146.0",
     "@cratis/arc.react": "22.146.0",
     "@cratis/components": "4.38.1",
-    "@cratis/fundamentals": "7.27.0",
-    "@cratis/scene.blueprint.default": "4.86.0",
-    "@cratis/scene.components": "4.86.0",
-    "@cratis/scene.engine": "4.86.0",
-    "@cratis/scene.model": "4.86.0",
-    "@cratis/scene.primereact": "4.86.0",
-    "@cratis/scene.react": "4.86.0",
-    "@primereact/ui": "11.2.0",
+    "@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",
+    "@primereact/ui": "11.2.2",
     "@primeuix/themes": "3.0.1",
     "lucide-react": "1.52.0",
-    "primereact": "11.2.0",
-    "react": "19.3.0",
-    "react-dom": "19.3.0",
+    "primereact": "11.2.2",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
     "vite": "8.3.5"
   },
   "peerDependenciesMeta": {
@@ -74,15 +74,15 @@
     }
   },
   "devDependencies": {
-    "@primereact/core": "11.2.0",
+    "@primereact/core": "11.2.2",
     "@testing-library/react": "16.3.3",
-    "@types/node": "26.6.4",
+    "@types/node": "26.6.6",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
-    "@vitejs/plugin-react": "6.1.1",
-    "jsdom": "30.1.2",
-    "react-dom": "19.3.0",
+    "@vitejs/plugin-react": "6.1.2",
+    "jsdom": "30.1.3",
+    "react-dom": "19.3.1",
     "typescript": "6.0.3",
-    "vitest": "5.0.3"
+    "vitest": "5.0.5"
   }
 }

package/dist/src/StageGuardedAction.d.ts

@@ -1,20 +0,0 @@
-import type { ExternalComponent } from '@cratis/scene.model';
-import type { InteractionHandlers } from '@cratis/scene.react';
-export interface StageGuardedActionProps {
-    element: ExternalComponent;
-    interactions?: InteractionHandlers;
-}
-/** Whether an element is an action authored with `when ... otherwise`. */
-export declare function isGuardedAction(element: ExternalComponent): boolean;
-/**
- * Renders an action authored with `when <guard> execute <command> ... otherwise ...`.
- *
- * The guard is evaluated against the item on every render, so the action follows the data: a work item that is
- * closed while the screen is open stops offering Close. The first alternative that holds is the command the action
- * executes; when none holds, the authored `otherwise` decides - `hidden` renders nothing, `execute` offers its
- * command instead. Without an item there is nothing to decide about, so nothing is offered.
- *
- * A guard this runtime cannot evaluate never lets a command through: the action is shown disabled with the
- * diagnostic, which is the same refusal Stage reports when it admits the Scene.
- */
-export declare function StageGuardedAction({ element, interactions }: StageGuardedActionProps): import("react").JSX.Element | null;

package/dist/src/stageGuards.d.ts

@@ -1,88 +0,0 @@
-/**
- * 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;