@cratis/event-models 0.329.2 → 0.331.1

package/dist/screen-editor/{CollectionEditor-DAZxBd7y.js → CollectionEditor-BvAtXikL.js}

@@ -1,41 +1,41 @@
 import { n as T, t as A } from "./allowedIconChoices-KSkQ6blx.js";
-import { a as u, i as D, r as P, t as $ } from "./iconDiagnostics-Ds4CnqD0.js";
+import { a as u, i as D, r as P, t as $ } from "./iconDiagnostics-BZq0t8-V.js";
 import { StructuredPropertyEditor as U } from "./StructuredPropertyEditor-Bd-8GBgK.js";
 import { jsx as n, jsxs as c } from "react/jsx-runtime";
-import { CollectionOperation as C, DestinationKind as v, PropertyValueType as L, SceneEditKind as O } from "@cratis/scene.model";
+import { CollectionOperation as C, DestinationKind as v, PropertyValueType as L, SceneEditKind as S } from "@cratis/scene.model";
 import { OrderedItemEditor as F } from "@cratis/components/ConfigurationEditor";
 var K = /* @__PURE__ */ new Set([
   "label",
   "icon",
   "destination"
-]), j = (e) => e.valueType === L.Collection && e.item !== void 0 && e.item.properties.every((i) => K.has(i.path)), N = (e) => typeof e == "string" ? e : "";
+]), j = (e) => e.valueType === L.Collection && e.item !== void 0 && e.item.properties.every((t) => K.has(t.path)), N = (e) => typeof e == "string" ? e : "";
 function V(e) {
-  const i = (e.items ?? []).map((t) => ({
-    id: t.id,
-    label: N(t.values.label),
-    ...t.values.icon ? { icon: t.values.icon } : {},
-    ...Z(t.values.destination) ? {
-      destinationReference: t.values.destination,
-      destination: t.values.destination.screen
+  const t = (e.items ?? []).map((i) => ({
+    id: i.id,
+    label: N(i.values.label),
+    ...i.values.icon ? { icon: i.values.icon } : {},
+    ...Z(i.values.destination) ? {
+      destinationReference: i.values.destination,
+      destination: i.values.destination.screen
     } : {},
-    values: t.values,
-    editable: t.editable
+    values: i.values,
+    editable: i.editable
   }));
   return {
-    fixed: i.filter((t) => !t.editable),
-    items: i.filter((t) => t.editable)
+    fixed: t.filter((i) => !i.editable),
+    items: t.filter((i) => i.editable)
   };
 }
 function W(e) {
-  const i = new Set(e.operations ?? []), t = i.has(C.EditFields), r = e.descriptor.constraints?.maximumItems;
+  const t = new Set(e.operations ?? []), i = t.has(C.EditFields), r = e.descriptor.constraints?.maximumItems;
   return {
-    add: i.has(C.Add),
-    remove: i.has(C.Remove),
-    reorder: i.has(C.Reorder),
+    add: t.has(C.Add),
+    remove: t.has(C.Remove),
+    reorder: t.has(C.Reorder),
     fields: {
-      label: t ? "editable" : "readonly",
-      icon: t ? "editable" : "readonly",
-      destination: t ? "editable" : "readonly"
+      label: i ? "editable" : "readonly",
+      icon: i ? "editable" : "readonly",
+      destination: i ? "editable" : "readonly"
     },
     ...r !== void 0 ? { maxItems: r } : {},
     ...e.reason ? { reasons: {
@@ -45,46 +45,46 @@ function W(e) {
     } } : {}
   };
 }
-function _(e, i, t) {
+function _(e, t, i) {
   const r = {
     component: e,
-    path: i.descriptor.path
+    path: t.descriptor.path
   };
-  switch (t.kind) {
+  switch (i.kind) {
     case "add":
       return [{
-        kind: O.AddCollectionItem,
+        kind: S.AddCollectionItem,
         ...r,
         item: {
-          id: t.item.id,
-          values: M(t.item)
+          id: i.item.id,
+          values: M(i.item)
         },
-        index: t.index
+        index: i.index
       }];
     case "remove":
       return [{
-        kind: O.RemoveCollectionItem,
+        kind: S.RemoveCollectionItem,
         ...r,
-        itemId: t.item.id
+        itemId: i.item.id
       }];
     case "move":
       return [{
-        kind: O.ReorderCollectionItem,
+        kind: S.ReorderCollectionItem,
         ...r,
-        itemId: t.item.id,
-        index: t.toIndex
+        itemId: i.item.id,
+        index: i.toIndex
       }];
     case "update":
       return [{
-        kind: O.EditCollectionItem,
+        kind: S.EditCollectionItem,
         ...r,
-        itemId: t.item.id,
-        field: t.field,
-        value: z(t.item, t.field)
+        itemId: i.item.id,
+        field: i.field,
+        value: z(i.item, i.field)
       }];
   }
 }
-var z = (e, i) => i === "destination" ? x(e) : e[i], M = (e) => ({
+var z = (e, t) => t === "destination" ? x(e) : e[t], M = (e) => ({
   ...e.values,
   label: e.label,
   ...e.icon ? { icon: e.icon } : {},
@@ -108,38 +108,38 @@ function Z(e) {
     "kind",
     "dialog",
     "routeParameterBindings"
-  ].some((i) => i in e);
+  ].some((t) => t in e);
 }
 var q = /^:[A-Za-z_][A-Za-z0-9_]*$/;
-function B(e, i) {
+function B(e, t) {
   if (!e) return [];
-  const t = [];
-  return !e.screen && !e.route && !e.dialog && !e.slice && t.push(u.NoTarget), e.screen && !i.screens.includes(e.screen) && t.push(u.UnknownScreen), e.route !== void 0 && !G(e.route, e.kind) && t.push(u.InvalidRoute), e.outlet && !i.outlets.includes(e.outlet) && t.push(u.UnknownOutlet), e.dialog && !i.dialogTemplates.includes(e.dialog) && t.push(u.UnknownDialog), e.slice && !i.slices.includes(e.slice) && t.push(u.UnknownSlice), e.kind === v.Outlet && !e.outlet && t.push(u.OutletKindWithoutOutlet), e.kind === v.Dialog && !e.dialog && t.push(u.DialogKindWithoutDialog), e.kind === v.External && !e.route && t.push(u.ExternalKindWithoutRoute), t;
+  const i = [];
+  return !e.screen && !e.route && !e.dialog && !e.slice && i.push(u.NoTarget), e.screen && !t.screens.includes(e.screen) && i.push(u.UnknownScreen), e.route !== void 0 && !G(e.route, e.kind) && i.push(u.InvalidRoute), e.slot && !t.slots.includes(e.slot) && i.push(u.UnknownSlot), e.dialog && !t.dialogTemplates.includes(e.dialog) && i.push(u.UnknownDialog), e.slice && !t.slices.includes(e.slice) && i.push(u.UnknownSlice), e.kind === v.Slot && !e.slot && i.push(u.SlotKindWithoutSlot), e.kind === v.Dialog && !e.dialog && i.push(u.DialogKindWithoutDialog), e.kind === v.External && !e.route && i.push(u.ExternalKindWithoutRoute), i;
 }
-function G(e, i) {
-  if (i === v.External) return H(e);
+function G(e, t) {
+  if (t === v.External) return H(e);
   if (!e.startsWith("/") || /\s/.test(e) || e.includes("//")) return !1;
-  const t = e.split("/").filter((r) => r.startsWith(":"));
-  return t.every((r) => q.test(r)) ? new Set(t).size === t.length : !1;
+  const i = e.split("/").filter((r) => r.startsWith(":"));
+  return i.every((r) => q.test(r)) ? new Set(i).size === i.length : !1;
 }
 function H(e) {
   try {
-    const i = new URL(e);
-    return i.protocol === "https:" || i.protocol === "http:";
+    const t = new URL(e);
+    return t.protocol === "https:" || t.protocol === "http:";
   } catch {
     return !1;
   }
 }
-var J = ({ id: e, label: i, value: t, destinations: r, outlets: s, dialogTemplates: p, problems: m = [], disabled: I, strings: a, onChange: b }) => {
-  const d = t ?? {}, h = (o) => b(Y({
+var J = ({ id: e, label: t, value: i, destinations: r, slots: s, dialogTemplates: p, problems: m = [], disabled: I, strings: a, onChange: b }) => {
+  const d = i ?? {}, h = (o) => b(Y({
     ...d,
     ...o
-  })), y = () => b(void 0), g = `${e}-outlets`, k = `${e}-dialogs`;
+  })), y = () => b(void 0), g = `${e}-slots`, k = `${e}-dialogs`;
   return /* @__PURE__ */ c("fieldset", {
     className: "studio-editor-destination",
     disabled: I,
     children: [
-      /* @__PURE__ */ n("legend", { children: i || a.label }),
+      /* @__PURE__ */ n("legend", { children: t || a.label }),
       /* @__PURE__ */ c("label", { children: [/* @__PURE__ */ n("span", { children: a.screen }), /* @__PURE__ */ c("select", {
         value: d.screen ?? "",
         onChange: (o) => h({ screen: o.target.value || void 0 }),
@@ -172,8 +172,8 @@ var J = ({ id: e, label: i, value: t, destinations: r, outlets: s, dialogTemplat
             children: a.kinds.default
           }),
           /* @__PURE__ */ n("option", {
-            value: v.Outlet,
-            children: a.kinds.outlet
+            value: v.Slot,
+            children: a.kinds.slot
           }),
           /* @__PURE__ */ n("option", {
             value: v.Dialog,
@@ -186,11 +186,11 @@ var J = ({ id: e, label: i, value: t, destinations: r, outlets: s, dialogTemplat
         ]
       })] }),
       /* @__PURE__ */ c("label", { children: [
-        /* @__PURE__ */ n("span", { children: a.outlet }),
+        /* @__PURE__ */ n("span", { children: a.slot }),
         /* @__PURE__ */ n("input", {
           list: g,
-          value: d.outlet ?? "",
-          onChange: (o) => h({ outlet: o.target.value || void 0 })
+          value: d.slot ?? "",
+          onChange: (o) => h({ slot: o.target.value || void 0 })
         }),
         /* @__PURE__ */ n("datalist", {
           id: g,
@@ -217,7 +217,7 @@ var J = ({ id: e, label: i, value: t, destinations: r, outlets: s, dialogTemplat
       m.length > 0 && /* @__PURE__ */ n("ul", {
         className: "studio-editor-diagnostics",
         role: "alert",
-        "aria-label": i || a.label,
+        "aria-label": t || a.label,
         children: m.map((o) => /* @__PURE__ */ n("li", {
           "data-severity": "error",
           children: a.problems[o]
@@ -229,31 +229,31 @@ var J = ({ id: e, label: i, value: t, destinations: r, outlets: s, dialogTemplat
 function Q(e) {
   return e.group ? `${e.group} / ${e.label}` : e.label;
 }
-function X(e, i) {
-  return !!e && !i.some((t) => t.id === e);
+function X(e, t) {
+  return !!e && !t.some((i) => i.id === e);
 }
 function Y(e) {
-  const i = {
+  const t = {
     ...e,
     ...e.screen ? { screen: e.screen } : {},
     ...e.route ? { route: e.route } : {},
-    ...e.outlet ? { outlet: e.outlet } : {},
+    ...e.slot ? { slot: e.slot } : {},
     ...e.dialog ? { dialog: e.dialog } : {}
   };
-  for (const t of [
+  for (const i of [
     "screen",
     "route",
-    "outlet",
+    "slot",
     "dialog",
     "kind"
-  ]) i[t] || delete i[t];
-  return Object.keys(i).length > 0 ? i : void 0;
+  ]) t[i] || delete t[i];
+  return Object.keys(t).length > 0 ? t : void 0;
 }
 var ee = ({ context: e }) => {
-  const { session: i } = e;
-  if (!i) return null;
-  const { controller: t, environment: r, property: s, screenStrings: p } = i, m = e.selection?.id ?? "", I = r.destinations, a = e.lookups.icons, { items: b, fixed: d } = V(s), h = $(a.diagnostics, s.descriptor.path), y = W(s), g = y.fields.destination !== "readonly" || s.editable, k = [...d, ...b].filter((l) => l.destination !== void 0 || l.destinationReference !== void 0 || g), o = P(r, t.document), R = te(o, s), S = (l, f) => {
-    t.setCollectionItemDestination(m, s.descriptor.path, l.id, f, p.properties.destination.label);
+  const { session: t } = e;
+  if (!t) return null;
+  const { controller: i, environment: r, property: s, screenStrings: p } = t, m = e.selection?.id ?? "", I = r.destinations, a = e.lookups.icons, { items: b, fixed: d } = V(s), h = $(a.diagnostics, s.descriptor.path), y = W(s), g = y.fields.destination !== "readonly" || s.editable, k = [...d, ...b].filter((l) => l.destination !== void 0 || l.destinationReference !== void 0 || g), o = P(r, i.document), R = ie(o, s), O = (l, f) => {
+    i.setCollectionItemDestination(m, s.descriptor.path, l.id, f, p.properties.destination.label);
   };
   return /* @__PURE__ */ c("section", {
     className: "studio-editor-properties__collection",
@@ -283,7 +283,7 @@ var ee = ({ context: e }) => {
         label: "",
         values: {}
       }),
-      onChange: (l) => t.applyAll(_(m, s, l), p.properties.itemsLabel)
+      onChange: (l) => i.applyAll(_(m, s, l), p.properties.itemsLabel)
     }), k.length > 0 && /* @__PURE__ */ c("div", {
       className: "studio-editor-destinations",
       children: [/* @__PURE__ */ n("strong", { children: p.properties.destination.label }), k.map((l) => /* @__PURE__ */ n(J, {
@@ -291,20 +291,20 @@ var ee = ({ context: e }) => {
         label: l.label,
         value: l.destinationReference,
         destinations: I,
-        outlets: R.outlets,
+        slots: R.slots,
         dialogTemplates: R.dialogTemplates,
         problems: B(l.destinationReference, o),
         disabled: !g || d.some((f) => f.id === l.id),
         strings: p.properties.destination,
-        onChange: (f) => S(l, f)
+        onChange: (f) => O(l, f)
       }, l.id))]
     })]
   });
 };
-function te(e, i) {
-  const t = (i.items ?? []).map((s) => E(s.values.destination) ? s.values.destination.outlet : void 0).filter(w), r = (i.items ?? []).map((s) => E(s.values.destination) ? s.values.destination.dialog : void 0).filter(w);
+function ie(e, t) {
+  const i = (t.items ?? []).map((s) => E(s.values.destination) ? s.values.destination.slot : void 0).filter(w), r = (t.items ?? []).map((s) => E(s.values.destination) ? s.values.destination.dialog : void 0).filter(w);
   return {
-    outlets: D([...e.outlets, ...t]),
+    slots: D([...e.slots, ...i]),
     dialogTemplates: D([...e.dialogTemplates, ...r])
   };
 }

package/dist/screen-editor/ScreenEditor/Actions/ActionModel.d.ts

@@ -1,7 +1,8 @@
-import type { ActionPresentation } from './ActionPresentation';
+import type { Opens } from '@cratis/scene.model';
 export interface ActionModel {
     sliceId: string;
     sliceName: string;
     inputs: Record<string, string>;
-    presentation: ActionPresentation;
+    opens: Opens;
+    opensIn?: string;
 }

package/dist/screen-editor/ScreenEditor/Actions/actionBehavior.d.ts

@@ -1,7 +1,8 @@
 import { type SceneEdit } from '@cratis/scene.model';
 import type { ActionModel } from './ActionModel';
 export declare const actionComponentName = "action";
-export declare const presentationProperty = "presentation";
+export declare const opensProperty = "opens";
+export declare const opensInProperty = "opensIn";
 export declare const argumentsProperty = "arguments";
 export declare function readActionModel(properties: Record<string, unknown> | undefined, sliceName?: string): ActionModel | undefined;
 export declare function toActionProperties(model: ActionModel): Record<string, unknown>;

package/dist/screen-editor/ScreenEditor/DesignMode/DesignModeStrings.d.ts

@@ -22,6 +22,9 @@ export interface DesignModeStrings {
         notInvokableHeading: string;
         upgrade: string;
         upgradeNote: (slice: string) => string;
+        shows: string;
+        showsHelp: string;
+        displays: Record<string, string>;
     };
     navigation: {
         application: string;

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/navigationDocument.d.ts

@@ -1,8 +1,8 @@
-import { NavigationRegionKind, type NavigationModel, type NavItem, type SceneDocument } from '@cratis/scene.model';
+import { type NavigationModel, type OutletNavigationItem, type SceneDocument } from '@cratis/scene.model';
 export type NavigationDocument = SceneDocument & {
     navigation?: NavigationModel;
 };
 export declare const emptyNavigation: () => NavigationModel;
 export declare const navigationOf: (document: SceneDocument) => NavigationModel;
 export declare const withNavigation: (document: SceneDocument, navigation: NavigationModel) => SceneDocument;
-export declare function ownItemsOf(navigation: NavigationModel, module: string | undefined, region: NavigationRegionKind): NavItem[];
+export declare function ownItemsOf(navigation: NavigationModel, module: string | undefined, outlet: string): OutletNavigationItem[];

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/navigationItemOps.d.ts

@@ -1,11 +1,11 @@
-import type { NavItem } from '@cratis/scene.model';
-export declare const changeItem: (items: readonly NavItem[], id: string, change: Partial<NavItem>) => NavItem[];
-export declare const removeItem: (items: readonly NavItem[], id: string) => NavItem[];
-export declare function findItem(items: readonly NavItem[], id: string): NavItem | undefined;
-export declare function siblingsOf(items: readonly NavItem[], id: string): readonly NavItem[] | undefined;
-export declare function moveItem(items: readonly NavItem[], id: string, to: number): NavItem[];
-export declare const cloneItem: (item: NavItem, newId: () => string) => NavItem;
-export declare function duplicateItem(items: readonly NavItem[], id: string, newId: () => string): {
-    items: NavItem[];
-    copy?: NavItem;
+import type { OutletNavigationItem } from '@cratis/scene.model';
+export declare const changeItem: (items: readonly OutletNavigationItem[], id: string, change: Partial<OutletNavigationItem>) => OutletNavigationItem[];
+export declare const removeItem: (items: readonly OutletNavigationItem[], id: string) => OutletNavigationItem[];
+export declare function findItem(items: readonly OutletNavigationItem[], id: string): OutletNavigationItem | undefined;
+export declare function siblingsOf(items: readonly OutletNavigationItem[], id: string): readonly OutletNavigationItem[] | undefined;
+export declare function moveItem(items: readonly OutletNavigationItem[], id: string, to: number): OutletNavigationItem[];
+export declare const cloneItem: (item: OutletNavigationItem, newId: () => string) => OutletNavigationItem;
+export declare function duplicateItem(items: readonly OutletNavigationItem[], id: string, newId: () => string): {
+    items: OutletNavigationItem[];
+    copy?: OutletNavigationItem;
 };

package/dist/screen-editor/ScreenEditor/DesignMode/designModeTypes.d.ts

@@ -8,6 +8,7 @@ export declare const designModeActions: {
     readonly slot: 'slot';
     readonly slice: 'slice';
     readonly emphasis: 'emphasis';
+    readonly display: 'display';
     readonly moveEarlier: 'moveEarlier';
     readonly moveLater: 'moveLater';
     readonly duplicate: 'duplicate';

package/dist/screen-editor/ScreenEditor/DesignMode/outletItemSource.d.ts

@@ -0,0 +1,10 @@
+import { type ApplicationStructure, type InspectedProperty } from '@cratis/scene.model';
+import { type DesignModeItemSource } from './designModeTypes';
+export interface OutletItemSourceInputs {
+    componentId: string;
+    property: InspectedProperty;
+    newId: () => string;
+    startingLabel: string;
+    structure?: ApplicationStructure;
+}
+export declare function createOutletItemSource({ componentId, property, newId, startingLabel, structure }: OutletItemSourceInputs): DesignModeItemSource;

package/dist/screen-editor/ScreenEditor/DesignMode/resolveDesignMode.d.ts

@@ -1,7 +1,7 @@
 import type { ApplicationStructure, DestinationReference, ExternalComponent, NodeInspection, SceneElement } from '@cratis/scene.model';
 import { type DescriptorCatalog } from '@cratis/scene.engine';
 import type { Ownership } from '../Structure/Ownership';
-import type { DesignModeItemSource, DesignModeSubject } from './designModeTypes';
+import { type DesignModeItemSource, type DesignModeSubject } from './designModeTypes';
 export interface DesignModeInputs {
     roots: readonly SceneElement[];
     catalog: DescriptorCatalog;

package/dist/screen-editor/ScreenEditor/Destinations/DestinationProblemKind.d.ts

@@ -2,10 +2,10 @@ export declare enum DestinationProblemKind {
     NoTarget = "noTarget",
     UnknownScreen = "unknownScreen",
     InvalidRoute = "invalidRoute",
-    UnknownOutlet = "unknownOutlet",
+    UnknownSlot = "unknownSlot",
     UnknownDialog = "unknownDialog",
     UnknownSlice = "unknownSlice",
-    OutletKindWithoutOutlet = "outletKindWithoutOutlet",
+    SlotKindWithoutSlot = "slotKindWithoutSlot",
     DialogKindWithoutDialog = "dialogKindWithoutDialog",
     ExternalKindWithoutRoute = "externalKindWithoutRoute"
 }

package/dist/screen-editor/ScreenEditor/Destinations/destinationProblems.d.ts

@@ -2,7 +2,7 @@ import { DestinationKind, type DestinationReference } from '@cratis/scene.model'
 import { DestinationProblemKind } from './DestinationProblemKind';
 export interface DestinationTargets {
     screens: readonly string[];
-    outlets: readonly string[];
+    slots: readonly string[];
     dialogTemplates: readonly string[];
     slices: readonly string[];
 }

package/dist/screen-editor/ScreenEditor/Document/upgradeStoredDocument.d.ts

@@ -0,0 +1,2 @@
+export declare function upgradeStoredDocument<T>(document: T): T;
+export declare function parseStoredDocument<T>(text: string): T;

package/dist/screen-editor/ScreenEditor/Host/ScreenEditorController.d.ts

@@ -1,6 +1,6 @@
 import type { CanvasPlacement } from '../Document/placeOnCanvas';
 import type { PreparedSceneScreenDraft, SceneScreenDraftPreparation } from '../Drafting/SceneScreenDraft';
-import type { ApplicationStructure, Behavior, DestinationReference, DialogTemplate, NavigationModel, Form, NodeInspection, Outlet, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement, ScreenTemplate, TemplateMetadata } from '@cratis/scene.model';
+import type { ApplicationStructure, Behavior, DestinationReference, DialogTemplate, NavigationModel, Form, NodeInspection, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement, ScreenTemplate, Slot, TemplateMetadata } from '@cratis/scene.model';
 import type { EditingContext, NavigationEdit } from '@cratis/scene.engine';
 import type { Ownership } from '../Structure/Ownership';
 import type { StructureEdit } from '../Structure/StructureEdit';
@@ -61,7 +61,7 @@ export interface ScreenEditorController {
     canRemove: (elementId: string) => boolean;
     setProperty: (property: NodeInspection['properties'][number], value: unknown) => void;
     setScreenForms: (forms: Form[], label: string) => void;
-    setScreenTemplateOutlets: (templateName: string, outlets: Outlet[], label: string) => void;
+    setScreenTemplateSlots: (templateName: string, slots: Slot[], label: string) => void;
     setScreenTemplateMetadata: (templateName: string, metadata: TemplateMetadata | undefined, label: string) => void;
     setDialogTemplates: (templates: DialogTemplate[], label: string) => void;
     setCollectionItemDestination: (componentId: string, path: string, itemId: string, destination: DestinationReference | undefined, label: string) => void;

package/dist/screen-editor/ScreenEditor/Inspector/DestinationReferenceFields.d.ts

@@ -7,11 +7,11 @@ export interface DestinationReferenceFieldsProps {
     label: string;
     value: DestinationReference | undefined;
     destinations: readonly ConfigurationDestination[];
-    outlets: readonly string[];
+    slots: readonly string[];
     dialogTemplates: readonly string[];
     problems?: readonly DestinationProblemKind[];
     disabled: boolean;
     strings: ScreenEditorStrings['properties']['destination'];
     onChange: (destination: DestinationReference | undefined) => void;
 }
-export declare const DestinationReferenceFields: ({ id, label, value, destinations, outlets, dialogTemplates, problems, disabled, strings, onChange }: DestinationReferenceFieldsProps) => import("react").JSX.Element;
+export declare const DestinationReferenceFields: ({ id, label, value, destinations, slots, dialogTemplates, problems, disabled, strings, onChange }: DestinationReferenceFieldsProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Inspector/OutletButtonSection.d.ts

@@ -0,0 +1,14 @@
+import type { InspectedProperty } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { EditorContext } from '../PropertyEditors/Registry/PropertyEditorProps';
+import type { PropertyEditorRegistry } from '../PropertyEditors/Registry/PropertyEditorRegistry';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface OutletButtonSectionProps {
+    controller: ScreenEditorController;
+    strings: ScreenEditorStrings;
+    componentId: string;
+    items: InspectedProperty;
+    registry: PropertyEditorRegistry;
+    context: EditorContext;
+}
+export declare const OutletButtonSection: ({ controller, strings, componentId, items, registry, context }: OutletButtonSectionProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/Inspector/ScreenEditorStrings.d.ts

@@ -128,16 +128,26 @@ export interface ScreenEditorStrings {
             apply: string;
             discard: string;
         };
-        outlets: {
+        slots: {
             label: string;
             name: string;
-            description: string;
+            role: string;
+            roles: {
+                none: string;
+                page: string;
+                pane: string;
+                panel: string;
+            };
+            routed: string;
+            routedHint: string;
+            optional: string;
+            optionalHint: string;
             add: string;
             remove: string;
             moveUp: string;
             moveDown: string;
             unnamed: string;
-            newOutletName: string;
+            newSlotName: string;
         };
         destination: {
             label: string;
@@ -146,13 +156,13 @@ export interface ScreenEditorStrings {
             missingScreen: (screen: string) => string;
             route: string;
             routePlaceholder: string;
-            outlet: string;
+            slot: string;
             dialog: string;
             clear: string;
             kind: string;
             kinds: {
                 default: string;
-                outlet: string;
+                slot: string;
                 dialog: string;
                 external: string;
             };
@@ -276,12 +286,15 @@ export interface ScreenEditorStrings {
             slice: string;
             chooseSlice: string;
             inputs: string;
-            presentation: string;
-            presentations: {
+            opens: string;
+            openings: {
+                automatic: string;
                 none: string;
-                modal: string;
+                dialog: string;
                 drawer: string;
+                slot: string;
             };
+            opensIn: string;
             sourceFor: (input: string) => string;
             problems: {
                 missingSlice: string;

package/dist/screen-editor/ScreenEditor/Inspector/SlotListEditor.d.ts

@@ -0,0 +1,13 @@
+import { type Slot } from '@cratis/scene.model';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface SlotListEditorProps {
+    slots: readonly Slot[];
+    primarySlot: string;
+    hint: string;
+    disabled: boolean;
+    strings: ScreenEditorStrings['properties']['slots'];
+    onChange: (slots: Slot[]) => void;
+}
+export declare const SlotListEditor: ({ slots, primarySlot, hint, disabled, strings, onChange }: SlotListEditorProps) => import("react").JSX.Element;
+export declare function cleanSlot(slot: Slot): Slot;
+export declare function nextSlotName(slots: readonly Slot[], baseName: string): string;

package/dist/screen-editor/ScreenEditor/Inspector/ToolbarButtonSection.d.ts

@@ -1,4 +1,4 @@
-import type { SceneElement } from '@cratis/scene.model';
+import { type SceneElement } from '@cratis/scene.model';
 import type { ScreenEditorController } from '../Host/ScreenEditorController';
 import type { ScreenEditorStrings } from './ScreenEditorStrings';
 export interface ToolbarButtonSectionProps {

package/dist/screen-editor/ScreenEditor/Inspector/localizedDisplay.d.ts

@@ -0,0 +1,3 @@
+import type { InspectedProperty } from '@cratis/scene.model';
+import type { DesignModeStrings } from '../DesignMode/DesignModeStrings';
+export declare function localizedDisplay(property: InspectedProperty, text: DesignModeStrings['toolbar']): InspectedProperty;

package/dist/screen-editor/ScreenEditor/Runtime/withOutletItemKind.d.ts

@@ -0,0 +1,2 @@
+import { type ComponentDescriptor } from '@cratis/scene.model';
+export declare function withOutletItemKind(descriptor: ComponentDescriptor): ComponentDescriptor;

package/dist/screen-editor/ScreenEditor/Surface/designTimePointer.d.ts

@@ -7,5 +7,5 @@ export interface DesignTimePointerDecision {
 }
 export declare function decideDesignTimePointer(type: string, target: EventTarget | null, button?: number): DesignTimePointerDecision;
 export declare function elementIdAt(target: EventTarget | null): string | undefined;
-export declare const itemHitSelector = "[data-scene-item], [data-scene-nav-item]";
+export declare const itemHitSelector = "[data-scene-item], [data-scene-nav-item], [data-scene-outlet-item]";
 export declare function itemIdAt(target: EventTarget | null): string | undefined;

package/dist/screen-editor/ScreenEditor/Toolbar/toolbarDiagnostics.d.ts

@@ -1,8 +1,11 @@
-import type { ApplicationStructure, SceneElement } from '@cratis/scene.model';
+import { type ApplicationStructure, type SceneElement, type ToolbarButton } from '@cratis/scene.model';
 export interface ToolbarFinding {
     code: string;
     severity: 'error' | 'warning';
     message: string;
     button: string;
 }
+export declare function isToolbarElement(element: SceneElement): boolean;
+export declare function toolbarButtonsOf(toolbar: SceneElement): ToolbarButton[];
 export declare function toolbarDiagnostics(structure: ApplicationStructure, toolbar: SceneElement): ToolbarFinding[];
+export declare function buttonDiagnostics(structure: ApplicationStructure, button: ToolbarButton): ToolbarFinding[];

package/dist/screen-editor/ScreenTemplates/ApplicationTemplate.d.ts

@@ -13,10 +13,10 @@ export interface ApplicationTemplate {
     sliceKinds?: SliceKind[];
     /** `Root` when the template is made to be the application's shell, which its document says. */
     role?: TemplateRole;
-    /** The outlet of a shell that holds the screen when a screen does not say which one it fills. */
-    primaryOutlet?: string;
-    /** The outlets a shell offers. */
-    outlets?: string[];
+    /** The slot of a shell that holds the screen when a screen does not say which one it fills. */
+    primarySlot?: string;
+    /** The slots a shell offers. */
+    slots?: string[];
     /**
      * The template as its saved Scene document declares it - the content it places and the arrangement it lays out - when the document is known. A shell that is
      * drawn needs it: the metadata above says where a template may be used, only the template itself says what it draws.